CVE-2026-43499-root-KernelSU

# CVE-2026-43499-root-KernelSU

Anpassung zur lokalen Privilegieneskalation (Local Privilege Escalation) auf Basis der Kernel-Schwachstelle CVE-2026-43499, mit integriertem eingebettetem KernelSU. Beim Kompilieren wird `preload.so` erzeugt; nach erfolgreicher Ausnutzung wird KernelSU im `late-load`-Modus (Jailbreak-Modus) gestartet. Unterstützt die Generierung von `target.h` aus `(xbl_config.img / vendor_boot.img) + boot.img`.

Adaption zur lokalen Privilegieneskalation auf Basis einer Kernel-Schwachstelle, mit integriertem eingebettetem KernelSU.
Kompiliert und erzeugt `preload.so`; nach erfolgreicher Ausnutzung wird KernelSU im `late-load`-Modus (Jailbreak-Modus) gestartet.
Unterstützt die Generierung von `target.h` aus `(xbl_config.img / vendor_boot.img) + boot.img`. oder anderweitig

Referenzierte Projekte:

- [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]
>Die unbefugte Ausnutzung von Schwachstellen zur Beschädigung, Kompromittierung oder zum unbefugten Zugriff auf Computersysteme ist gesetzlich verboten. Dieses Projekt wird ausschließlich zu Forschungs-, Bildungs- und Lernzwecken bereitgestellt und darf nur in Systemen und Umgebungen verwendet werden, für die eine vorherige Autorisierung erteilt wurde. Jegliche Nutzung dieses Projekts erfolgt auf eigenes Risiko des Nutzers. Die Autoren und Mitwirkenden übernehmen keinerlei Haftung für Missbrauch dieses Projekts oder für Schäden, Verluste oder rechtliche Konsequenzen, die sich aus seiner Nutzung ergeben.
>
>Haftungsausschluss: Unbefugte Ausnutzung von Schwachstellen zur Beschädigung, zum Eindringen oder zum unbefugten Zugriff auf Computersysteme kann gegen einschlägige Gesetze und Vorschriften verstoßen. Dieses Projekt ist ausschließlich für Sicherheitsforschung, Lernen und Tests in Systemen und Umgebungen bestimmt, für die eine rechtmäßige Autorisierung erteilt wurde. Jegliche direkten oder indirekten Schäden, rechtlichen Verpflichtungen und sonstigen Konsequenzen, die durch Nutzung, Missbrauch oder Modifikation dieses Projekts entstehen, trägt der Nutzer selbst; die Autoren und Mitwirkenden dieses Projekts übernehmen keinerlei Haftung.

## Betroffene Versionen

**Wenn Ihre Kernel-Version {Linux Kernel} ist, ist sie von dieser Schwachstelle betroffen**

- 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**


## Aktueller Status

| Target | Status |
| --- | --- |
| `rodin` (Standard) | Verifiziert |
| Andere `src/targets/*` | Referenz |

## Verzeichnisstruktur

```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/
        └── ...
```

## Erstellung

### Abhängigkeiten

- Linux-Host
- Android NDK
  - Standardpfad: `~/android-ndk-r29`
  - Oder setzen: `ANDROID_NDK_HOME` / `ANDROID_NDK_ROOT` / `NDK_ROOT`
- `make`
- `git`

### Erstellung

```bash
make PROJECT=<target> -j$(nproc)
```

Ausgabe:

```text
build/<target>/bin/preload.so
```

### Verfügbare Targets anzeigen

```bash
make list-projects
```

## target.h generieren

Dieses Repository enthält bereits ein einheitliches Target-Generierungsskript:

```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` ist das Einstiegsskript. Es orientiert sich an den Target-Generierungsabläufen des übergeordneten Verzeichnisses und kapselt diese; schließlich wird ein vollständiges, an den Quellcode dieses Repos angepasstes `src/targets/<project>/target.h` ausgegeben.

Das Skript erzwingt keine Prüfung von `CONFIG_DEBUG_INFO_BTF=y` im IKCONFIG. Wenn die Strukturfeld-Offsets oder das percpu `entry_task`-Layout nicht verifiziert werden können, wird eine Warnung ausgegeben und die Generierung fortgesetzt.

Wenn im Image überhaupt kein nutzbares BTF vorhanden ist, z. B. wenn Folgendes erscheint:

```text
有效 vmlinux BTF 候选不唯一: []
```

wechselt der Generator in den **No-BTF-Fallback**:

- Funktions-/Globalobjekt-Symboloffsets werden weiterhin aus den kallsyms des aktuellen `boot.img` wiederhergestellt;
- Strukturfeld-/Layout-Makros, die nicht aus BTF wiederhergestellt werden können, werden von der Vorlagen-Target übernommen; die Standardvorlage ist `rodin`;
- Am Anfang des generierten Headers wird eine Warnung geschrieben, die `without BTF` und die verwendete Vorlage kennzeichnet;
- Ein solcher Header gewährleistet eine bestmögliche Kompilierbarkeit, die Laufzeitzuverlässigkeit muss jedoch auf echter Hardware verifiziert werden.

Die Fallback-Vorlage kann angegeben werden:

```bash
tools/generate_target.py --project <project> --boot boot.img --profile profile.json --template-target rodin
# oder
TARGET_TEMPLATE=rodin tools/generate_target.py --project <project> --boot boot.img --profile profile.json
```

#### 1. Generierung mit boot.img + profile JSON

```bash
make generate-target PROJECT=<project> BOOT=/path/to/boot.img PROFILE=/path/to/profile.json
```

Standardmäßig geschrieben nach:

```text
src/targets/<project>/target.h
```

Das Skript kann auch direkt aufgerufen werden:

```bash
tools/generate_target.py --project <project> --boot /path/to/boot.img --profile /path/to/profile.json
```

`profile.json` muss Informationen zur physischen Adresse enthalten, z. B.:

```json
{
  "p0_phys_offset": "0x40000000",
  "p0_kernel_phys_load": "0x40000000"
}
```

#### 2. Profil von einem gerooteten ADB-Gerät erkennen

Nur das Profil generieren:

```bash
make detect-profile PROFILE_OUT=profile.json
```

Profil erkennen und sofort target generieren:

```bash
tools/generate_target.py --project <project> --boot /path/to/boot.img \
  --detect-adb-and-generate --profile-out profile.json
```

#### 3. Generierung aus (xbl_config.img / vendor_boot.img) + boot.img

Das Skript legt auch die weiteren vom Generator des übergeordneten Verzeichnisses unterstützten Einstiegspunkte offen:

```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
```

##### Beispiele

```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
```

Form der erfolgreichen Ausgabe:

```text
生成成功: .../src/targets/<project>/target.h
kernel SHA-256: <sha256>
target macros: 168
```

`rodin` behält standardmäßig das auf echter Hardware verifizierte:

```c
#define MM_STRUCT_SZ 0x500
```

Zum Überschreiben:

```bash
tools/generate_target.py --project rodin --boot boot.img --profile profile.json --mm-struct-sz 0x...
```

## Neues Target hinzufügen

Empfohlen wird die Generierung aus einem passenden Boot-Image und Profil:

```bash
make generate-target PROJECT=<project> BOOT=/path/to/boot.img PROFILE=/path/to/profile.json
make PROJECT=<project> -j$(nproc)
```

Ein vollständiger Target-Header enthält:

- Direct-Map-/Physical-Profile-Konstanten
- KASLR-Slide-Objekt-Offsets
- task-/cred-/SELinux-Offsets
- pipe-/fops-/configfs-Offsets
- pselect-Layoutwerte, z. B. `PSELECT_WAITER_WORD_SHIFT`
- `MM_STRUCT_SZ` und KernelSnitch-Abstimmungswerte

## Ausführung

Der aktuelle Quellcode enthält bereits Standardwerte. Für den normalen Betrieb genügt es, `LD_PRELOAD` zu setzen und ein beliebiges Programm auszuführen (empfohlen: `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'
```

## Standard-Laufzeitparameter

Die aktuelle Standardkonfiguration lautet wie folgt:

| Einstellung | Standardwert | Beschreibung |
| --- | --- | --- |
| `KSUD_LATE_LOAD` | `1` | führt `ksud late-load` aus |
| `KSUD_ALLOW_SHELL` | `1` | übergibt `--allow-shell` |
| `KSUD_PACKAGE` | `me.weishu.kernelsu` | an ksud übergebener Manager-Paketname (scheint keine Wirkung zu haben) |
| `KSUD_DST` | `/data/local/tmp/ksud` | Extraktionspfad für das eingebettete ksud |
| `KSUD_SKIP_WRITE` | `0` | extrahiert das eingebettete ksud standardmäßig |
| `KSUD_DEFER_TO_PARENT` | `1` | startet ksud aus dem gepatchten Eltern-/aktuellen Prozesspfad |
| `ROOT_PATCH_SELF` | `1` | patcht den aktuellen Prozess auf uid 0 |
| `DISABLE_SELINUX` | `1` | setzt beim Root-Patch SELinux enforcing auf permissive |
| `ROOT_EXIT_SLEEP` | unset / `0` | kein zusätzlicher Sleep vor der Rückkehr |

Standardmäßig tatsächlich ausgeführtes ksud-Kommando:

```bash
/data/local/tmp/ksud late-load --allow-shell --package-name me.weishu.kernelsu
```

Diese Umgebungsvariablen können zur Laufzeit weiterhin überschrieben werden, z. B.:

```bash
adb shell 'KSUD_PACKAGE=com.example.manager LD_PRELOAD=/data/local/tmp/preload.so /system/bin/toybox id'
```

Wiederverwendung des bereits extrahierten `ksud`:

```bash
adb shell 'KSUD_SKIP_WRITE=1 LD_PRELOAD=/data/local/tmp/preload.so /system/bin/toybox id'
```

## Bereinigung

```bash
make clean
```

`make clean` behält `build/embed/ksud`, da `src/ksud_blob.S` es wie folgt einbettet:

```asm
.incbin "build/embed/ksud"
```

Wenn `build/embed/ksud` durch manuelle Bereinigung verloren geht, kann es wiederhergestellt werden:

```bash
git checkout -- build/embed/ksud
```

## Häufig gestellte Fragen

### `.incbin "build/embed/ksud"` nicht gefunden

Nach der Wiederherstellung des integrierten Payloads neu erstellen:

```bash
git checkout -- build/embed/ksud
make PROJECT=rodin -j$(nproc)
```

### FOPS-Route gibt `success=0` zurück

`rodin` erwartet die Verwendung des legacy/simple pselect-Layouts:

```text
pselect fdset simple layout shift=0
pselect returned attempt=1 ret=9 ... success=1
```

Wenn der Gerätezustand durch fehlgeschlagene Versuche beeinträchtigt wurde, direkt neu starten und erneut versuchen:

```bash
adb reboot
```

### `F_SETPIPE_SZ` gibt `EPERM` zurück

In der Regel ein Zustandsproblem durch fehlgeschlagene/übrig gebliebene Versuche; ein Neustart ist der schnellste Weg zur Bereinigung:

```bash
adb reboot
```

### `ksud` startet, aber `/proc/modules` enthält kein KernelSU

Logs anzeigen:

```bash
adb shell 'cat /data/local/tmp/ksud.log /data/local/tmp/ksud.preload.log 2>/dev/null || true'
```

Bei Bedarf manuell in einer Root-Shell ausführen:

```bash
/data/local/tmp/ksud late-load --allow-shell --package-name me.weishu.kernelsu
```

## Lizenz

GPL-3.0. Siehe [`LICENSE`](https://github.com/woshimaniubi8/cve-2026-43499-root-kernelsu/blob/main/LICENSE).