GhostLock — OnePlus

Exploit noyau ciblant les appareils OnePlus avec bootloader verrouillé. Utilise CVE-2026-43499 pour obtenir un accès root sans déverrouiller le bootloader ni modifier boot.img.

Recherche en sécurité autorisée et usage éducatif uniquement.

Table des matières

• Aperçu de la vulnérabilité
• Appareils supportés
• Prérequis
• Compilation
• Utilisation
• Modes d'exécution
• Détails techniques
• Structure des fichiers
• Ajout de nouveaux appareils
• FAQ

Aperçu de la vulnérabilité

Cause racine

L'appel système pselect6 copie fd_set sur la pile du noyau. Combiné au mécanisme d'attente futex PI, une trame de pile libérée peut être réallouée en tant que structure rt_mutex_waiter. Lors du parcours de la chaîne PI, le rééquilibrage de l'arbre rouge-noir écrit des données contrôlées à des adresses noyau arbitraires.

Chaîne

futex PI UAF (CVE-2026-43499)
  ├─ Forger un objet rt_mutex_waiter
  ├─ Contrôler la pile noyau via la disposition fd_set de pselect/select
  ├─ Déclencher une opération PI rt_mutex pour écriture arbitraire
  ├─ Écriture 1 : selinux_state.enforcing = 0
  └─ Écriture 2 : cred → init_cred (uid=0, capacités complètes)

Appareils supportés

D'autres appareils OnePlus de la même famille SoC, Android 16 ou noyau 6.12.x peuvent être adaptés via l'extraction des offsets de boot.img.

Prérequis

ksud (Requis pour KernelSU)

GhostLock gère l'élévation de privilèges. L'installation de KernelSU nécessite ksud (fourni avec kernelsu.ko spécifique au KMI) :

Sans ksud, l'exploit obtient toujours un shell root uid=0, mais KernelSU ne sera pas installé et su ne persistera pas.

Compilation

Prérequis

• Android NDK (r25+)
• Définir ANDROID_NDK_HOME ou ANDROID_NDK_ROOT

Compilation

# Par défaut (API 35)
make

# Spécifier le niveau API
make API=34

# Spécifier le chemin NDK
NDK=/chemin/vers/android-ndk make

Artefact

ghostlock — exécutable ARM64 ELF lié statiquement.

Utilisation

Configuration unique

# 1. Activer le mode ADB TCP
adb tcpip 5555

# 2. Transférer la clé ADB (nécessaire pour le mode bootstrap)
adb push ~/.android/adbkey /data/local/tmp/a/adbkey

# 3. Transférer l'exploit
adb push ghostlock /data/local/tmp/a/e
adb shell chmod 755 /data/local/tmp/a/e

Après le premier succès, resetprop définit automatiquement persist.adb.tcp.port=5555, permettant des exécutions entièrement automatiques lors des redémarrages suivants.

Modes d'exécution

Exploit complet (contexte shell ADB)

/data/local/tmp/a/e

• perf disponible, fuite précise de task_struct enfant
• Deux étapes : W1 désactive SELinux → W2 élévation de privilèges → chargement KernelSU

Mode Bootstrap (contexte application, seccomp restreint)

/data/local/tmp/a/e --bootstrap

1. Écriture 1 → désactiver SELinux
2. Utiliser les permissions libérées pour setprop activer ADB TCP 5555
3. Client Mini ADB intégré se connecte à 127.0.0.1:5555
4. Authentification RSA avec la clé pré-transférée
5. Exécution complète de l'exploit via ADB shell (sans seccomp)

Écriture 1 uniquement

/data/local/tmp/a/e --write1

• Jusqu'à 20 tentatives
• Utile pour le débogage ou une désactivation temporaire de SELinux

Détails techniques

1. Correspondance du noyau à l'exécution

Les offsets sont stockés dans src/devices/offsets.h sous forme de table de correspondance, indexée par uname -r. Le programme effectue la correspondance automatiquement au démarrage ; les noyaux inconnus sont rejetés.

static const struct kernel_offsets known_offsets[] = {
  OFFSETS_ENTRY("6.12.38-android16-5-...-ab14275539-4k", ...),
  OFFSETS_ENTRY("6.12.38-android16-5-...-ab14552068-4k", ...),
  OFFSETS_ENTRY("6.12.23-android16-5-...-ab14541642-4k", ...),
  { .uname_r = NULL }  /* sentinelle */
};

Sources d'offsets

Structs vérifiées par BTF

2. Contournement de KASLR

Mode SLIDE — Fuite de boot_id

Lorsque les pointeurs noyau sont restreints (kptr_restrict), divulguer l'adresse de base via boot_id écrasé avec une adresse noyau :

Lire /proc/sys/kernel/random/boot_id
  └─ L'UUID contient l'adresse nfulnl_logger
      └─ Décalage KASLR = adresse_fuite - image_offset
          └─ kaslr_base

Mode FOPS/CFI — Fuite de la table fops

Lorsque le périphérique ashmem est accessible, utiliser les primitives de lecture/écriture configfs pour lire les pointeurs de fonction de la table fops ashmem et calculer le décalage KASLR.

3. Arrosage du tas noyau

Forger des objets noyau sur des pages d'ordre 3 (32 Ko) :

• Fake file_operations — détourner le pointeur fops du miscdevice ashmem
• Fake rt_mutex_waiter — simuler un nœud d'attente dans la chaîne PI
• Fake task_struct — référence de tâche pendant le parcours PI
• Fake rt_mutex (verrou) — informations correctes waiter/owner

Implémenté via SKB (socket buffer) + KernelSnitch :

• KernelSnitch — collision de hachage futex pour divulguer les adresses mm_struct
• Arrosage SKB — sendmsg pour remplir le tas noyau

4. Lecture/écriture mémoire physique (Tube)

Après avoir obtenu la base KASLR, utiliser les buffers de tube pour un accès mémoire au niveau physique :

1. Localiser le buffer de tube dans la physmap
2. Forger la table d'opérations pipe_buffer pointant vers pipe_buf_ops connue
3. Détourner pipe_buffer.page vers l'adresse physique cible
4. Lecture/écriture physique arbitraire via les opérations normales de tube

Supporté : pipe_read64, pipe_write64, pipe_phys_read_data, pipe_phys_write_data

5. Écriture en deux étapes

Écriture 1 — Désactiver SELinux

Cible : selinux_state.enforcing (offset 0x00)
Méthode : écriture PI sur nœud enfant → forger __rb_parent_color du waiter
          pointant vers selinux_enforcing - 8
          le rééquilibrage rb-tree écrit 0x00

Écriture 2 — Élévation à root

Cible : pointeur cred du processus enfant
Méthode : 1. fork enfant → perf_find_task() localiser task_struct
        2. calculer l'offset du champ cred
        3. écriture PI sur nœud enfant → cred = init_cred (uid=0, caps complètes)
        4. effacer seccomp (TIF_SECCOMP + struct seccomp remis à zéro)

Une vérification de lecture des capacités est effectuée après l'écrasement de cred.

6. Client Mini ADB intégré

src/core/miniadb.c — client léger du protocole ADB pour le mode bootstrap :

1. Connexion TCP 127.0.0.1:5555
2. A_CNXN → demande de connexion
3. A_AUTH → défi de jeton RSA
4. dlopen("libcrypto.so") → PEM_read_bio_RSAPrivateKey → RSA_sign
5. A_AUTH (AUTH_SIGNATURE) → réponse signée
6. A_CNXN → connexion établie
7. A_OPEN "shell:/data/local/tmp/a/e" → exploit complet

Supporte les algorithmes de signature SHA-1 et SHA-256.

Structure des fichiers

ghostlock-oneplus/
├── Makefile                        # Configuration de compilation (cross-compilation NDK)
├── README.md                       # Documentation
├── src/
│   ├── core/                       # Code principal de l'exploit
│   │   ├── main.c                  # Point d'entrée : écriture deux étapes + shell root
│   │   ├── fops.c                  # Mode FOPS/CFI : route pselect, écriture PI, fuite KASLR
│   │   ├── util.c                  # Utilitaires : arrosage tas, KASLR, primitives R/W noyau
│   │   ├── slide.c                 # Mode SLIDE : fuite KASLR boot_id + route pselect
│   │   ├── pipe.c                  # Lecture/écriture mémoire physique via buffer tube (physrw)
│   │   ├── root.c                  # Écrasement cred, effacement seccomp, gestion enfant root
│   │   ├── miniadb.c              # Client ADB intégré (TCP + auth RSA)
│   │   ├── common.h               # Macros globales, structs, déclarations, constantes
│   │   ├── target.h               # Disposition mémoire cible / offsets struct / paramètres KASLR
│   │   ├── offset.h               # Pont de configuration cible à la compilation (#include TARGET_CONFIG_H)
│   │   └── kernelsnitch/          # KernelSnitch — fuite d'adresse mm_struct
│   │       ├── kernelsnitch.h     # Algorithme principal : collision de hachage futex + force brute
│   │       ├── futex_hash.h       # Fonction de hachage futex
│   │       ├── timeutils.h        # Mesure de timestamp CPU (RDTSC)
│   │       └── utils.h            # Macros d'aide (pr_info / SYSCHK / ASSERT etc.)
│   └── devices/                   # Tables d'offsets par appareil
│       ├── offsets.h              # Agréger tous les offsets d'appareil (table de recherche + sentinelle)
│       ├── ace6t/offsets.h        # Offsets OnePlus Ace 6T (2 versions de noyau)
│       └── op15/offsets.h         # Offsets OnePlus 15 (1 version de noyau)
└── tools/                         # Chaîne d'extraction d'offsets
    ├── extract_target.py          # Extraire les offsets des symboles globaux kallsyms (28 éléments)
    └── extract_btf.py             # Extraire les offsets des champs de structs BTF (57 éléments)

Aperçu du module principal

Ajout de nouveaux appareils

Seul le fichier boot.img de l'appareil cible est nécessaire — pas de root, pas d'accès à l'appareil requis.

Extraire les offsets

# 1. Extraire le noyau de boot.img
python -c "import struct; d=open('boot.img','rb').read(); \
           open('kernel','wb').write(d[4096:4096+struct.unpack_from('<I',d,8)[0]])"

# 2. Obtenir kallsyms (root : adb shell su -c 'cat /proc/kallsyms' > kallsyms.txt)
#    Ou à partir de vmlinux : nm vmlinux > kallsyms.txt

# 3. Extraire les offsets des symboles globaux
python tools/extract_target.py     # 28 offsets, vérification automatique

# 4. Extraire les offsets des champs de structs
python tools/extract_btf.py kernel  # 57 offsets, vérification automatique

Étapes d'adaptation

1. Créer src/devices/<nom>/offsets.h (voir ace6t/offsets.h)
2. #include le dans src/devices/offsets.h
3. Mettre à jour src/core/target.h KIMAGE_TEXT_BASE et la disposition mémoire si nécessaire
4. Recompiler

Réglages inter-appareils

FAQ

Q : Aucune sortie lors de l'exécution ?

Assurez-vous d'exécuter dans un shell ADB. Le contexte application nécessite --bootstrap.

Q : "no offsets for this kernel" ?

La version de votre noyau n'est pas encore supportée. Suivez Ajout de nouveaux appareils pour extraire les offsets et recompiler.

Q : L'écriture 1 échoue toujours ?

• Assurez-vous de l'affinité avec le cœur CPU correct (macro CORE)
• Ajuster la temporisation PSELECT_ENTER_DELAY_USEC
• Vérifier les processus interférents

Q : L'écriture 2 renvoie 0 pour perf ?

• Vérifier si seccomp bloque perf_event_open (utiliser --bootstrap en contexte application)
• Vérifier que le contournement KASLR a réussi (kaslr_base valide)

Q : KernelSU ne se charge pas ?

• Confirmer que ksud existe et est exécutable
• Vérifier l'intégrité du fichier de politique réseau (correctif load_policy)

Licence

Recherche en sécurité autorisée et usage éducatif uniquement.