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 90c245f32..02b81c6db 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 @@ -1,4 +1,4 @@ -# Analiza Malvera +# Malware Analysis {{#include ../../banners/hacktricks-training.md}} @@ -6,7 +6,7 @@ [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) -## Online Usluge +## Online servisi - [VirusTotal](https://www.virustotal.com/gui/home/upload) - [HybridAnalysis](https://www.hybrid-analysis.com) @@ -14,42 +14,42 @@ - [Intezer](https://analyze.intezer.com) - [Any.Run](https://any.run/) -## Offline Antivirus i Alati za Detekciju +## Offline antivirus i alati za detekciju ### Yara -#### Instaliraj +#### Instalacija ```bash sudo apt-get install -y yara ``` #### Pripremite pravila -Use this script to download and merge all the yara malware rules from github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ -Create the _**rules**_ directory and execute it. This will create a file called _**malware_rules.yar**_ which contains all the yara rules for malware. +Koristite ovaj skript da preuzmete i spojite sve yara malware rules sa github-a: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ +Kreirajte direktorijum _**rules**_ i izvršite skript. Ovo će kreirati fajl nazvan _**malware_rules.yar**_ koji sadrži sve yara rules za malware. ```bash wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py mkdir rules python malware_yara_rules.py ``` -#### Skeneranje +#### Skeniranje ```bash yara -w malware_rules.yar image #Scan 1 file yara -w malware_rules.yar folder #Scan the whole folder ``` -#### YaraGen: Proverite malver i kreirajte pravila +#### YaraGen: Provera za malware i kreiranje pravila -Možete koristiti alat [**YaraGen**](https://github.com/Neo23x0/yarGen) za generisanje yara pravila iz binarnog fajla. Pogledajte ove tutorijale: [**Deo 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Deo 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Deo 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) +Možete koristiti alat [**YaraGen**](https://github.com/Neo23x0/yarGen) za generisanje yara rules iz binarnog fajla. Pogledajte ove tutorijale: [**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/ ``` ### ClamAV -#### Instaliraj +#### Instalacija ``` sudo apt-get install -y clamav ``` -#### Skeneranje +#### Skeniranje ```bash sudo freshclam #Update rules clamscan filepath #Scan 1 file @@ -57,21 +57,21 @@ clamscan folderpath #Scan the whole folder ``` ### [Capa](https://github.com/mandiant/capa) -**Capa** detektuje potencijalno zlonamerne **kapacitete** u izvršnim datotekama: PE, ELF, .NET. Tako će pronaći stvari kao što su Att\&ck taktike, ili sumnjivi kapaciteti kao što su: +**Capa** otkriva potencijalno maliciozne **capabilities** u izvršnim fajlovima: PE, ELF, .NET. Dakle, pronaći će stvari kao što su Att\&ck tactics, ili sumnjive capabilities kao što su: -- provera za OutputDebugString grešku -- pokretanje kao servis +- provera OutputDebugString error +- pokretanje kao service - kreiranje procesa -Preuzmite ga u [**Github repo**](https://github.com/mandiant/capa). +Get it int he [**Github repo**](https://github.com/mandiant/capa). ### IOCs -IOC znači Indikator Kompromitacije. IOC je skup **uslova koji identifikuju** neki potencijalno neželjeni softver ili potvrđeni **malver**. Plave ekipe koriste ovu vrstu definicije da **traže ovu vrstu zlonamernih datoteka** u svojim **sistemima** i **mrežama**.\ -Deljenje ovih definicija je veoma korisno jer kada se malver identifikuje na računaru i kreira se IOC za taj malver, druge Plave ekipe mogu to koristiti da brže identifikuju malver. +IOC znači indikator kompromitovanja. IOC je skup **uslova koji identifikuju** neki potencijalno neželjeni softver ili potvrđeni **malware**. Blue Teams koriste ovaj tip definicije da **pretraže ovakve maliciozne fajlove** u svojim **sistemima** i **mrežama**.\ +Deljenje ovih definicija je veoma korisno: kada se malware identifikuje na računaru i kreira IOC za taj malware, drugi Blue Teams mogu ga brže identifikovati. -Alat za kreiranje ili modifikovanje IOCs je [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ -Možete koristiti alate kao što su [**Redline**](https://www.fireeye.com/services/freeware/redline.html) da **tražite definisane IOCs na uređaju**. +Alat za kreiranje ili izmenu IOC-ova je [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ +Možete koristiti alate kao što su [**Redline**](https://www.fireeye.com/services/freeware/redline.html) da **pretražite definisane IOCs na uređaju**. ### Loki @@ -92,41 +92,41 @@ 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/) je skener malvera za Linux koji je objavljen pod GNU GPLv2 licencom, a dizajniran je oko pretnji sa kojima se suočavaju deljeni hostovani okruženja. Koristi podatke o pretnjama iz sistema za detekciju upada na mrežnom rubu kako bi izvukao malver koji se aktivno koristi u napadima i generiše potpise za detekciju. Pored toga, podaci o pretnjama se takođe dobijaju iz korisničkih prijava putem LMD checkout funkcije i resursa zajednice malvera. +[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) je malware skener za Linux, objavljen pod GNU GPLv2 licencom, koji je dizajniran oko pretnji sa kojima se susreću okruženja sa deljenim hostingom. Koristi threat data iz network edge intrusion detection systems da izvuče malware koji se aktivno koristi u napadima i generiše potpise za detekciju. Pored toga, threat data se takođe dobija iz korisničkih prijava putem LMD checkout feature i iz resursa malware zajednice. ### rkhunter -Alati poput [**rkhunter**](http://rkhunter.sourceforge.net) mogu se koristiti za proveru datotečnog sistema na moguće **rootkitove** i malver. +Alati poput [**rkhunter**](http://rkhunter.sourceforge.net) mogu se koristiti za proveru datotečnog sistema zbog mogućih **rootkits** i **malware**. ```bash sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress] ``` ### FLOSS -[**FLOSS**](https://github.com/mandiant/flare-floss) je alat koji pokušava da pronađe obfuskirane stringove unutar izvršnih datoteka koristeći različite tehnike. +[**FLOSS**](https://github.com/mandiant/flare-floss) je alat koji pokušava da pronađe obfuscated strings unutar executables koristeći različite tehnike. ### PEpper -[PEpper ](https://github.com/Th3Hurrican3/PEpper)proverava neke osnovne stvari unutar izvršne datoteke (binarni podaci, entropija, URL-ovi i IP adrese, neka yara pravila). +[PEpper ](https://github.com/Th3Hurrican3/PEpper)proverava neke osnovne stvari unutar executable-a (binary data, entropy, URLs and IPs, neke yara rules). ### PEstudio -[PEstudio](https://www.winitor.com/download) je alat koji omogućava dobijanje informacija o Windows izvršnim datotekama kao što su uvozi, izvozi, zaglavlja, ali će takođe proveriti virus total i pronaći potencijalne Att\&ck tehnike. +[PEstudio](https://www.winitor.com/download) je alat koji omogućava pribavljanje informacija o Windows executables kao što su imports, exports, headers, ali takođe proverava virus total i pronalazi potencijalne Att\&ck techniques. ### Detect It Easy(DiE) -[**DiE**](https://github.com/horsicq/Detect-It-Easy/) je alat za detekciju da li je datoteka **kriptovana** i takođe pronalazi **pakere**. +[**DiE**](https://github.com/horsicq/Detect-It-Easy/) je alat za detekciju da li je fajl **encrypted** i takođe pronalazi **packers**. ### NeoPI -[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)je Python skripta koja koristi razne **statističke metode** za detekciju **obfuskovanog** i **kriptovanog** sadržaja unutar tekstualnih/skript datoteka. Namena NeoPI-a je da pomogne u **detekciji skrivenog web shell koda**. +[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)je Python skripta koja koristi razne **statistical methods** da detektuje **obfuscated** i **encrypted** sadržaje unutar text/script fajlova. Namena NeoPI-ja je da pomogne u **detection of hidden web shell code**. ### **php-malware-finder** -[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) se trudi da detektuje **obfuskovani**/**sumnjivi kod** kao i datoteke koje koriste **PHP** funkcije često korišćene u **malverima**/webshell-ima. +[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) se maksimalno trudi da detektuje **obfuscated**/**dodgy code** kao i fajlove koji koriste **PHP** funkcije često korišćene u **malwares**/webshells. ### Apple Binary Signatures -Kada proveravate neki **uzorak malvera**, uvek treba da **proverite potpis** binarne datoteke jer **razvijač** koji je potpisao može već biti **povezan** sa **malverom.** +Prilikom provere nekog **malware sample** you should always **check the signature** of the binary as the **developer** that signed it may be already **related** with **malware.** ```bash #Get signer codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" @@ -137,29 +137,41 @@ codesign --verify --verbose /Applications/Safari.app #Check if the signature is valid spctl --assess --verbose /Applications/Safari.app ``` -## Tehnike Detekcije +## Tehnike detekcije -### Stacking Fajlova +### File Stacking -Ako znate da je neka fascikla koja sadrži **fajlove** web servera **poslednji put ažurirana na neki datum**. **Proverite** **datum** kada su svi **fajlovi** na **web serveru** kreirani i modifikovani i ako je neki datum **sumnjiv**, proverite taj fajl. +Ako znate da je neka fascikla koja sadrži **files** web servera poslednji put ažurirana na određeni datum, **proverite** datume kada su svi **files** u **web server** kreirani i izmenjeni; ako je neki datum **sumnjiv**, proverite taj file. -### Osnovne Linije +### Baselines -Ako fajlovi u fascikli **ne bi trebali biti modifikovani**, možete izračunati **hash** **originalnih fajlova** iz fascikle i **uporediti** ih sa **trenutnim**. Sve što je modifikovano će biti **sumnjivo**. +Ako **files** neke fascikle **ne bi trebali biti modifikovani**, možete izračunati **hash** **original files** fascikle i **uporediti** ih sa **current** verzijama. Sve što je izmenjeno biće **sumnjivo**. -### Statistička Analiza +### Statistical Analysis -Kada su informacije sačuvane u logovima, možete **proveriti statistiku kao što je koliko puta je svaki fajl web servera bio pristupljen, jer bi web shell mogao biti jedan od naj**. +Kada se informacije čuvaju u logs, možete **proveriti statistiku** — npr. koliko puta je svaki file web servera bio pristupan, jer web shell može biti među najčešće pristupanima. --- -## Deobfuskacija Dinamičkog Kontrolnog Tok (JMP/CALL RAX Dispečeri) +### Android in-app native telemetry (no root) -Moderne porodice malvera snažno zloupotrebljavaju obfuskaciju Kontrolnog Toka (CFG): umesto direktnog skakanja/pozivanja, izračunavaju odredište u vreme izvođenja i izvršavaju `jmp rax` ili `call rax`. Mali *dispečer* (obično devet instrukcija) postavlja konačni cilj u zavisnosti od CPU `ZF`/`CF` flagova, potpuno razbijajući statičku CFG obnovu. +Na Android-u možete instrumentovati native kod unutar procesa ciljne aplikacije tako što ćete prethodno učitati malu logger biblioteku pre nego što se ostale JNI libs inicijalizuju. Ovo daje ranu vidljivost native ponašanja bez system-wide hook-ova ili root-a. Popularan pristup je SoTap: ubacite libsotap.so za odgovarajući ABI u APK i injektujte poziv System.loadLibrary("sotap") rano (npr. u static initializer ili Application.onCreate), zatim prikupite logs iz internog/eksternog puta ili pomoću Logcat kao fallback. -Tehnika – prikazana od strane SLOW#TEMPEST loader-a – može biti savladana trostepenim radnim tokom koji se oslanja samo na IDAPython i Unicorn CPU emulator. +See the Android native reversing page for setup details and log paths: -### 1. Pronađite svaki indirektni skok / poziv +{{#ref}} +../../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +{{#endref}} + +--- + +## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers) + +Savremene malware familije intenzivno zloupotrebljavaju Control-Flow Graph (CFG) obfuskaciju: umesto direktnog jump/call oni izračunavaju destinaciju u run-time-u i izvršavaju `jmp rax` ili `call rax`. Mali *dispatcher* (tipično nine instructions) postavlja finalnu metu u zavisnosti od CPU `ZF`/`CF` zastavica, potpuno razbijajući statičko obnavljanje CFG-a. + +Tehniku – prikazanu od strane SLOW#TEMPEST loader-a – može se pobediti trostepenim workflow-om koji se oslanja samo na IDAPython i Unicorn CPU emulator. + +### 1. Locate every indirect jump / call ```python import idautils, idc @@ -183,7 +195,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. Emulirajte ga dva puta sa Unicorn +### 3. Emuliraj ga dva puta koristeći Unicorn ```python from unicorn import * from unicorn.x86_const import * @@ -199,9 +211,9 @@ mu.reg_write(UC_X86_REG_RAX, 0) mu.emu_start(BASE, BASE+len(code)) return mu.reg_read(UC_X86_REG_RAX) ``` -Pokrenite `run(code,0,0)` i `run(code,1,1)` da dobijete ciljeve *false* i *true* grana. +Pokrenite `run(code,0,0)` i `run(code,1,1)` da biste dobili ciljeve grana *false* i *true*. -### 4. Ponovo patch-ujte direktan skok / poziv +### 4. Vratite nazad direktni jump / call ```python import struct, ida_bytes @@ -210,27 +222,28 @@ 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(' cat lib/arm64-v8a/libfoo.so" > libfoo.so -# Ili iz APK (zip) +# Or from the APK (zip) unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/ ``` -2. **Identifikujte arhitekturu i zaštite** +2. **Identify architecture & protections** ```bash -file libfoo.so # arm64 ili arm32 / x86 -readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, itd. +file libfoo.so # arm64 or arm32 / x86 +readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **Nabrojite eksportovane simbole i JNI veze** +3. **List exported symbols & JNI bindings** ```bash -readelf -s libfoo.so | grep ' Java_' # dinamički povezani JNI -strings libfoo.so | grep -i "RegisterNatives" -n # statički registrovani JNI +readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI +strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` -4. **Učitajte u dekompajler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper ili Cutter/Rizin) i pokrenite automatsku analizu. Novije verzije Ghidre su uvele AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE oznake, što značajno poboljšava analizu biblioteka napravljenih sa Android 14 NDK. -5. **Odlučite o statičkom naspram dinamičkom obrnuto inženjerstvu:** skraćeni, obfuskovani kod često zahteva *instrumentaciju* (Frida, ptrace/gdbserver, LLDB). +4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis. +Novije verzije Ghidra-e su uvele AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE tagove, značajno poboljšavajući analizu biblioteka izgrađenih sa Android 14 NDK-om. +5. **Decide on static vs dynamic reversing:** stripped, obfuscated code često zahteva *instrumentation* (Frida, ptrace/gdbserver, LLDB). --- -### Dinamička Instrumentacija (Frida ≥ 16) +### Dinamička instrumentacija (Frida ≥ 16) -Frida 16-serija je donela nekoliko poboljšanja specifičnih za Android koja pomažu kada cilj koristi moderne Clang/LLD optimizacije: +Frida serija 16 donela je nekoliko Android-specifičnih poboljšanja koja pomažu kada meta koristi moderne Clang/LLD optimizacije: -* `thumb-relocator` sada može *hook-ovati male ARM/Thumb funkcije* generisane LLD-ovim agresivnim poravnanjem (`--icf=all`). -* Nabrajanje i ponovno povezivanje *ELF import slotova* funkcioniše na Androidu, omogućavajući po-modulno `dlopen()`/`dlsym()` patch-ovanje kada su inline hook-ovi odbijeni. +* `thumb-relocator` sada može *hook tiny ARM/Thumb functions* generisane agresivnim poravnanjem LLD-a (`--icf=all`). +* Enumerisanje i ponovno vezivanje *ELF import slots* radi na Androidu, omogućavajući per-module `dlopen()`/`dlsym()` patching kada inline hooks budu odbijeni. * Java hooking je ispravljen za novi **ART quick-entrypoint** koji se koristi kada su aplikacije kompajlirane sa `--enable-optimizations` na Android 14. -Primer: nabrajanje svih funkcija registrovanih putem `RegisterNatives` i ispis njihovih adresa u vreme izvođenja: +Primer: enumerisanje svih funkcija registrovanih putem `RegisterNatives` i dump njihovih adresa tokom izvršavanja: ```javascript Java.perform(function () { var Runtime = Java.use('java.lang.Runtime'); @@ -58,38 +61,76 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida će raditi odmah na PAC/BTI omogućеним uređajima (Pixel 8/Android 14+) sve dok koristite frida-server 16.2 ili noviji – ranije verzije nisu uspele da lociraju padding za inline hooks. citeturn5search2turn5search0 +Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks. + +### Process-local JNI telemetry via preloaded .so (SoTap) + +Kada je full-featured instrumentation previše ili je blokirana, i dalje možete dobiti vidljivost na nivou native tako što ćete preload-ovati mali logger unutar ciljnog procesa. SoTap je lagana Android native (.so) biblioteka koja beleži runtime ponašanje drugih JNI (.so) biblioteka unutar istog procesa aplikacije (nije potreban root). + +Key properties: +- Inicijalizuje se rano i posmatra JNI/native interakcije unutar procesa koji ga učitava. +- Čuva logove koristeći više putanja koje omogućavaju pisanje, sa automatskim prelaskom na Logcat kada je skladištenje ograničeno. +- Prilagodljivo iz izvornog koda: izmenite sotap.c da proširite/podesite šta se loguje i ponovo izgradite po ABI. + +Setup (repack the APK): +1) Ubacite odgovarajući ABI build u APK tako da loader može da pronađe libsotap.so: +- lib/arm64-v8a/libsotap.so (for arm64) +- lib/armeabi-v7a/libsotap.so (for arm32) +2) Obezbedite da SoTap bude učitan pre ostalih JNI libova. Inject-ujte poziv rano (npr. static initializer Application podklase ili onCreate) tako da se logger inicijalizuje prvi. Smali snippet example: +```smali +const-string v0, "sotap" +invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V +``` +3) Rebuild/sign/install, pokrenite aplikaciju, pa prikupite logove. + +Log paths (checked in order): +``` +/data/user/0/%s/files/sotap.log +/data/data/%s/files/sotap.log +/sdcard/Android/data/%s/files/sotap.log +/sdcard/Download/sotap-%s.log +# If all fail: fallback to Logcat only +``` +Beleške i rešavanje problema: +- ABI poravnanje je obavezno. Neusklađenost će izazvati UnsatisfiedLinkError i logger se neće učitati. +- Ograničenja skladištenja su česta na modernom Androidu; ako pisanje fajlova ne uspe, SoTap će i dalje emitovati preko Logcat. +- Ponašanje/detaljnost je predviđena za prilagođavanje; ponovo izgradite iz izvora nakon uređivanja sotap.c. + +Ovaj pristup je koristan za malware triage i JNI debugging gde je kritično posmatrati tokove poziva native koda od pokretanja procesa, ali root/system-wide hooks nisu dostupni. --- -### Nedavne ranjivosti koje vredi istražiti u APK-ima +### Nedavne ranjivosti vredne potrage u APK-ovima -| Godina | CVE | Pogođena biblioteka | Napomene | -|--------|-----|---------------------|----------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Prelivanje bafera na heap-u dostupno iz nativnog koda koji dekodira WebP slike. Nekoliko Android aplikacija sadrži ranjive verzije. Kada vidite `libwebp.so` unutar APK-a, proverite njegovu verziju i pokušajte sa eksploatacijom ili zakrpanjem.| citeturn2search0| -|2024|Više|OpenSSL 3.x serija|Nekoliko problema sa bezbednošću memorije i padding-oracle. Mnogi Flutter i ReactNative paketi isporučuju svoj `libcrypto.so`.| +| Year | CVE | Affected library | Notes | +|------|-----|------------------|-------| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow dostupan iz native koda koji dekodira WebP slike. Nekoliko Android aplikacija pakuje ranjive verzije. Kada vidite `libwebp.so` unutar APK-a, proverite njegovu verziju i pokušajte eksploatisati ili zakrpiti.| | +|2024|Multiple|OpenSSL 3.x series|Nekoliko problema vezanih za memory-safety i padding-oracle. Mnogi Flutter & ReactNative bundle-i isporučuju sopstveni `libcrypto.so`.| -Kada primetite *treće strane* `.so` datoteke unutar APK-a, uvek proverite njihov hash protiv uzvodnih obaveštenja. SCA (Analiza softverskog sastava) je retka na mobilnim uređajima, pa su zastarele ranjive verzije rasprostranjene. +Kada uočite *third-party* `.so` fajlove unutar APK-a, uvek uporedite njihov hash sa upstream advisories. SCA (Software Composition Analysis) je retka na mobilnim platformama, tako da su zastarele ranjive verzije učestale. --- -### Anti-reversing & Hardening trendovi (Android 13-15) +### Anti-Reversing & Hardening trends (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u sistemskim bibliotekama na podržanom ARMv8.3+ silikonu. Decompilatori sada prikazuju PAC‐povezane pseudo-instrukcije; za dinamičku analizu Frida ubrizgava trampoline *nakon* uklanjanja PAC-a, ali vaše prilagođene trampoline treba da pozivaju `pacda`/`autibsp` gde je to potrebno. -* **MTE & Scudo ojačani alokator:** označavanje memorije je opcionalno, ali mnoge aplikacije svesne Play-Integrity se grade sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da zabeležite greške u oznakama. -* **LLVM Obfuscator (neprozirni predikati, izravnavanje toka kontrole):** komercijalni pakeri (npr., Bangcle, SecNeo) sve više štite *nativni* kod, ne samo Java; očekujte lažne tokove kontrole i enkriptovane string blobove u `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u sistemskim bibliotekama na podržanom ARMv8.3+ hardveru. Decompileri sada prikazuju PAC‐relirane pseudo-instrukcije; za dinamičku analizu Frida ubacuje trampoline *posle* uklanjanja PAC, ali vaši prilagođeni trampolini treba da pozivaju `pacda`/`autibsp` gde je potrebno. +* **MTE & Scudo hardened allocator:** memory-tagging je opcionalno, ali mnoge aplikacije koje vode računa o Play-Integrity se grade sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da uhvatite tag faults. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercijalni packeri (npr. Bangcle, SecNeo) sve više štite *native* kod, ne samo Java; očekujte lažan control-flow i enkriptovane string blobove u `.rodata`. --- -### Resursi +### Resources -- **Učenje ARM Assemblera:** [Azeria Labs – Osnovi ARM Assemblera](https://azeria-labs.com/writing-arm-assembly-part-1/) -- **JNI & NDK Dokumentacija:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Saveti](https://developer.android.com/training/articles/perf-jni) · [NDK Vodiči](https://developer.android.com/ndk/guides/) -- **Debagovanje Nativnih Biblioteka:** [Debagovanje Android Nativnih Biblioteka koristeći 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) -### Reference +### References -- Frida 16.x promena (Android hooking, relokacija malih funkcija) – [frida.re/news](https://frida.re/news/) citeturn5search0 -- NVD obaveštenje za `libwebp` prelivanje CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) citeturn2search0 +- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) +- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) +- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) +- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/smali-changes.md b/src/mobile-pentesting/android-app-pentesting/smali-changes.md index df563e60c..62ca430c8 100644 --- a/src/mobile-pentesting/android-app-pentesting/smali-changes.md +++ b/src/mobile-pentesting/android-app-pentesting/smali-changes.md @@ -1,56 +1,57 @@ -# Smali - Decompiling/\[Modifying]/Compiling +# Smali - Dekompiliranje/[Modifikovanje]/Kompajliranje {{#include ../../banners/hacktricks-training.md}} -Ponekad je zanimljivo modifikovati kod aplikacije kako biste pristupili skrivenim informacijama (možda dobro obfuskovanim lozinkama ili zastavicama). Tada bi moglo biti zanimljivo dekompilirati apk, modifikovati kod i ponovo ga kompajlirati. + +Ponekad je interesantno izmeniti kod aplikacije kako biste pristupili skrivenim informacijama za vas (možda dobro obfuskovanim passwords ili flags). U tom slučaju može biti korisno dekompilirati apk, izmeniti kod i ponovo ga kompajlirati. **Opcodes reference:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) -## Fast Way +## Brzi način -Koristeći **Visual Studio Code** i [APKLab](https://github.com/APKLab/APKLab) ekstenziju, možete **automatski dekompilirati**, modifikovati, **ponovo kompajlirati**, potpisati i instalirati aplikaciju bez izvršavanja bilo koje komande. +Korišćenjem **Visual Studio Code** i ekstenzije [APKLab](https://github.com/APKLab/APKLab), možete **automatski dekompilirati**, izmeniti, **ponovo kompajlirati**, potpisati i instalirati aplikaciju bez pokretanja bilo koje komande. -Drugi **script** koji značajno olakšava ovaj zadatak je [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh) +Još jedna **skripta** koja znatno olakšava ovaj zadatak je [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh) -## Decompile the APK +## Dekompajliranje APK-a -Koristeći APKTool možete pristupiti **smali kodu i resursima**: +Korišćenjem APKTool možete pristupiti **smali code and resources**: ```bash apktool d APP.apk ``` -Ako **apktool** daje bilo kakvu grešku, pokušajte[ da instalirate **najnoviju verziju**](https://ibotpeaches.github.io/Apktool/install/) +Ako vam **apktool** prijavi bilo kakvu grešku, pokušajte[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) -Neki **zanimljivi fajlovi koje treba da pogledate su**: +Neke **zanimljive datoteke koje bi trebalo da pogledate su**: -- _res/values/strings.xml_ (i svi xml-ovi unutar res/values/\*) +- _res/values/strings.xml_ (and all xmls inside res/values/*) - _AndroidManifest.xml_ -- Bilo koji fajl sa ekstenzijom _.sqlite_ ili _.db_ +- Any file with extension _.sqlite_ or _.db_ -Ako `apktool` ima **problema sa dekodiranjem aplikacije**, pogledajte [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) ili pokušajte da koristite argument **`-r`** (Ne dekodiraj resurse). Tada, ako je problem bio u resursu, a ne u izvor kodu, nećete imati problem (takođe nećete dekompilirati resurse). +Ako `apktool` ima **probleme sa dekodiranjem aplikacije** pogledajte [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) ili pokušajte da koristite argument **`-r`** (Do not decode resources). Ako je problem bio u resource, a ne u source code, onda nećete imati problem (takođe nećete dekompajlirati resources). -## Promena smali koda +## Izmena smali koda -Možete **promeniti** **instrukcije**, promeniti **vrednost** nekih varijabli ili **dodati** nove instrukcije. Menjam Smali kod koristeći [**VS Code**](https://code.visualstudio.com), zatim instalirate **smalise ekstenziju** i editor će vam reći ako je neka **instrukcija netačna**.\ +Možete **izmeniti** **instrukcije**, promeniti **vrednost** nekih promenljivih ili **dodati** nove instrukcije. Menjam Smali kod koristeći [**VS Code**](https://code.visualstudio.com), zatim instalirajte **smalise extension** i editor će vam reći ako je neka **instrukcija netačna**.\ Neki **primeri** se mogu naći ovde: -- [Primeri smali promena](smali-changes.md) -- [Google CTF 2018 - Da li da igramo igru?](google-ctf-2018-shall-we-play-a-game.md) +- [Smali changes examples](smali-changes.md) +- [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md) -Ili možete [**proveriti ispod neke objašnjene Smali promene**](smali-changes.md#modifying-smali). +Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali). -## Rekompilacija APK-a +## Rekompajlirajte APK -Nakon modifikacije koda možete **rekompilirati** kod koristeći: +Nakon izmene koda možete **rekompajlirati** kod koristeći: ```bash apktool b . #In the folder generated when you decompiled the application ``` -To će **kompajlirati** novi APK **unutar** _**dist**_ foldera. +To će **compile** novi APK **u** _**dist**_ folderu. -Ako **apktool** izbaci **grešku**, pokušajte[ instalirati **najnoviju verziju**](https://ibotpeaches.github.io/Apktool/install/) +Ako **apktool** izbaci **error**, pokušajte [installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) ### **Potpišite novi APK** -Zatim, potrebno je da **generišete ključ** (bićete upitani za lozinku i za neke informacije koje možete popuniti nasumično): +Zatim, potrebno je da **generišete ključ** (biće zatražena lozinka i neke informacije koje možete popuniti nasumično): ```bash keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias ``` @@ -58,20 +59,20 @@ Na kraju, **potpišite** novi APK: ```bash jarsigner -keystore key.jks path/to/dist/* ``` -### Optimizujte novu aplikaciju +### Optimizacija nove aplikacije -**zipalign** je alat za usklađivanje arhiva koji pruža važnu optimizaciju za Android aplikacije (APK) datoteke. [More information here](https://developer.android.com/studio/command-line/zipalign). +**zipalign** je alat za poravnavanje arhiva koji obezbeđuje važnu optimizaciju Android aplikacija (APK) datoteka. [Više informacija ovde](https://developer.android.com/studio/command-line/zipalign). ```bash zipalign [-f] [-v] infile.apk outfile.apk zipalign -v 4 infile.apk ``` -### **Potpišite novi APK (ponovo?)** +### **Potpišite novi APK (opet?)** -Ako **preferirate** da koristite [**apksigner**](https://developer.android.com/studio/command-line/) umesto jarsigner, **trebalo bi da potpišete apk** nakon primene **optimizacije sa** zipalign. ALI OBRAZITE PAŽNJU DA TREBA DA **POTPIŠETE APLIKACIJU SAMO JEDNOM** SA jarsigner (pre zipalign) ILI SA aspsigner (posle zipalign). +Ako **više volite** da koristite [**apksigner**](https://developer.android.com/studio/command-line/) umesto jarsigner, **trebalo bi da potpišete apk** nakon primene **optimizacije pomoću** zipaling. ALI IMAJTE NA UMU DA MORATE **POTPISATI APLIKACIJU SAMO JEDNOM** SA jarsigner (pre zipalign) ILI SA aspsigner (posle zipaling). ```bash apksigner sign --ks key.jks ./dist/mycompiled.apk ``` -## Modifikovanje Smali +## Izmena Smali Za sledeći Hello World Java kod: ```java @@ -79,7 +80,7 @@ public static void printHelloWorld() { System.out.println("Hello World") } ``` -Smali kod bi bio: +Smali kod bi izgledao ovako: ```java .method public static printHelloWorld()V .registers 2 @@ -89,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V return-void .end method ``` -Skup instrukcija Smali je dostupan [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). +The Smali instruction set is available [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). -### Lake promene +### Light Changes -### Izmenite početne vrednosti promenljive unutar funkcije +### Modify initial values of a variable inside a function -Neke promenljive su definisane na početku funkcije koristeći opcode _const_, možete izmeniti njihove vrednosti, ili možete definisati nove: +Neke promenljive su definisane na početku funkcije pomoću opcode _const_; možete izmeniti njihove vrednosti ili definisati nove: ```bash #Number const v9, 0xf4240 @@ -103,7 +104,7 @@ const/4 v8, 0x1 #Strings const-string v5, "wins" ``` -### Osnovne Operacije +### Osnovne operacije ```bash #Math add-int/lit8 v0, v2, 0x1 #v2 + 0x1 and save it in v0 @@ -128,7 +129,7 @@ goto :goto_6 #Always go to: :goto_6 ``` ### Veće promene -### Zapisivanje +### Logovanje ```bash #Log win: iget v5, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Get this.o inside v5 @@ -139,17 +140,17 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin ``` Preporuke: -- Ako planirate da koristite deklarisane promenljive unutar funkcije (deklarisane v0,v1,v2...) stavite ove linije između _.local \_ i deklaracija promenljivih (_const v0, 0x1_) -- Ako želite da stavite kod za logovanje u sredinu koda funkcije: -- Dodajte 2 broju deklarisanih promenljivih: npr. od _.locals 10_ do _.locals 12_ -- Nove promenljive treba da budu sledeći brojevi već deklarisanih promenljivih (u ovom primeru treba da budu _v10_ i _v11_, zapamtite da počinje od v0). -- Promenite kod funkcije za logovanje i koristite _v10_ i _v11_ umesto _v5_ i _v1_. +- Ako ćete koristiti deklarisane promenljive unutar funkcije (deklarisane v0,v1,v2...) stavite ove linije između _.local _ i deklaracija promenljivih (_const v0, 0x1_) +- Ako želite da ubacite kod za logovanje u sred koda funkcije: +- Dodajte 2 broju deklarisanih promenljivih: Ex: from _.locals 10_ to _.locals 12_ +- Nove promenljive treba da budu naredni brojevi posle već deklarisanih promenljivih (u ovom primeru treba da budu _v10_ i _v11_, zapamtite da se kreće od v0). +- Izmenite kod funkcije za logovanje i koristite _v10_ i _v11_ umesto _v5_ i _v1_. -### Toasting +### Prikazivanje toast poruke Zapamtite da dodate 3 broju _.locals_ na početku funkcije. -Ovaj kod je pripremljen da bude umetnut u **sredinu funkcije** (**promenite** broj **promenljivih** po potrebi). Uzeće **vrednost ovog.o**, **transformisati** je u **String** i zatim **napraviti** **toast** sa njenom vrednošću. +Ovaj kod je pripremljen da se ubaci u **sredinu funkcije** (**izmenite** broj **promenljivih** po potrebi). Uzeće **vrednost this.o**, **pretvoriti** je u **String** i zatim napraviti **toast** sa tom vrednošću. ```bash const/4 v10, 0x1 const/4 v11, 0x1 @@ -161,4 +162,38 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/ move-result-object v12 invoke-virtual {v12}, Landroid/widget/Toast;->show()V ``` +### Učitavanje native biblioteke pri pokretanju (System.loadLibrary) + +Ponekad je potrebno prethodno učitati native biblioteku tako da se inicijalizuje pre drugih JNI libs (npr. da omogući process-local telemetry/logging). Možete ubaciti poziv System.loadLibrary() u statički inicijalizator ili rano u Application.onCreate(). Primer smali za statički inicijalizator klase (): +```smali +.class public Lcom/example/App; +.super Landroid/app/Application; + +.method static constructor ()V +.registers 1 +const-string v0, "sotap" # library name without lib...so prefix +invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V +return-void +.end method +``` +Alternativno, postavite iste dve instrukcije na početak vašeg Application.onCreate() da biste osigurali da se library učita što je ranije moguće: +```smali +.method public onCreate()V +.locals 1 + +const-string v0, "sotap" +invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V + +invoke-super {p0}, Landroid/app/Application;->onCreate()V +return-void +.end method +``` +Napomene: +- Uverite se da odgovarajuća ABI varijanta biblioteke postoji pod lib// (npr., arm64-v8a/armeabi-v7a) kako biste izbegli UnsatisfiedLinkError. +- Učitavanje vrlo rano (class static initializer) osigurava da native logger može da posmatra naknadnu JNI aktivnost. + +## Reference + +- SoTap: Lagan logger ponašanja JNI (.so) unutar aplikacije – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) + {{#include ../../banners/hacktricks-training.md}}