GhostLock - wrapper Android (indev.ghostlock.s26)

Wrapper Android one-click per 1ndevelopment/ghostlock-s26: GhostLock (CVE-2026-43499) portato sull'intera serie Samsung Galaxy S26 (Android 16 / GKI 6.12). Un solo APK, tre kernel line, corrispondenza dei parametri a runtime - nessuna variante dell'app per build.

Usare solo su dispositivi di propria proprietà o per i quali si è esplicitamente autorizzati a eseguire test. Il root temporaneo scompare al riavvio. Una seconda esecuzione dell'exploit nello stesso boot può mandare in crash il dispositivo - riavviare prima di ritentare.

Copertura: l'intera famiglia S26

L'exploit effettua la corrispondenza per kernel line, non per singola build (exploit/src/params_table.c è la fonte autorevole; ParamsTable.kt la rispecchia solo per il verdetto mostrato nella UI):

Build testate (17): S9420ZCS4AZG1, S9470ZCS4AZG1, S9480ZCS3AZF1, S9480ZCS4AZG1, S942BXXS4AZG5, S947BXXS3AZF1, S947BXXS4AZG5, S942QOPU1AZDE, S942U1UES4AZG3, S942USQS4AZG3, S947USQS4AZG3, S9480ZHS4AZG1, S948BXXS4AZG5/6, S948NKSS4AZG3, S948U1UES2AZE1, S948USQS4AZG3.

Le OTA sconosciute ricadono esattamente come nell'upstream params.c: prima la build esatta, poi stesso modello + CSC di 3 caratteri (riuso OTA), poi l'ultima voce per lo stesso dispositivo (contrassegnata come non verificata), altrimenti fail-closed (l'app mostra UNSUPPORTED e il layer nativo esce con codice 2). I modelli completamente sconosciuti vengono rifiutati - mai forzati.

Cosa fa l'app

Un unico grande pulsante - Root my S26 - esegue l'intera pipeline e racconta il tutto nella card Output:

1. Device check - modello/device/incremental/fingerprint più il verdetto sulla serie (esatto / riuso OTA / stima non verificata / non supportato). Le build non supportate si fermano qui (fail-closed, nessun boot-claim consumato).
2. Shizuku - usato automaticamente quando connesso (uid 2000 shell, stessa famiglia di contesto del flusso adb shell del README). Il permesso viene richiesto una volta all'avvio (e di nuovo se il server si riavvia); il flusso Root attende la concessione invece di interrompersi. Se il server è inattivo l'app apre il manager di Shizuku per consentirne l'avvio, poi ripiega sulla shell interna all'app. Aggiungere l'app alla allowlist di Shizuku elimina del tutto la richiesta.
3. Stage - copia preload.so, su_daemon, ksud in /data/local/tmp (preload.so, cve-2026-43499-root, ksud) ed esegue chmod su di essi. Se i file sono già stati inviati con adb push secondo il README upstream, vengono rilevati sul posto.
4. Run - esegue esattamente ciò che documenta l'upstream: env LD_PRELOAD=/data/local/tmp/preload.so sh (il costruttore della esegue la catena e chiama ; stdout il log dell'exploit), fino a 5 tentativi - la race è probabilistica. È disponibile un interruttore ma riavviare è più sicuro.

Sotto: una singola riga campo comando + Run as root (comandi one-shot tramite il protocollo C del demone su; la PTY interattiva è fuori scope per la v1), e un piccolo link Reset che cancella /data/local/tmp/ghostlock-boot.log così da poter ritentare un'esecuzione senza riavviare (l'upstream avverte che ciò può causare un panic - il riavvio è la via sicura).

Struttura del progetto

exploit/                  upstream vendored (Makefile + src/, autorevole)
ksud                      loader KernelSU precompilato upstream (ARM64 PIE, anche in assets)
app/src/main/assets/ksud  copia preparata inclusa nell'APK
app/src/main/assets/      + preload.so / su_daemon dopo stage-assets.sh
app/src/main/cpp/         ricompilazione CMake opzionale di preload.so da exploit/src
app/src/main/java/indev/ghostlock/s26/
  MainActivity.kt         UI (device / stage / run / shell / boot guard)
  ParamsTable.kt          rispecchia la tabella della serie (17 build, 3 line, 5 codename)
  DeviceCompat.kt         identità Build.* + verdetto sulla serie
  ShellRunner.kt          Shizuku (uid 2000) + fallback locale, staging
  SuClient.kt             client in modalità 'C' su /data/local/tmp/temp_su.sock
  GhostlockManager.kt     interprete dei codici di uscita (0/1/2/3/4)
PORTING.upstream.md       note di porting (nuovo firmware = nuova riga in device_map)

Build

Requisiti: Android Studio (JBR 21) / SDK 35 / NDK r26+ / CMake 3.22.1 / JDK 17.

# 1. Build the native payloads with the NDK (upstream flow):
cd exploit && make preload
#   -> build/bin/preload.so, build/embed/su_daemon_aarch64_pie

# 2. Stage them into the APK assets:
./stage-assets.sh

# 3. Build the app:
./gradlew :app:assembleDebug
#   -> app/build/outputs/apk/debug/app-debug.apk

ksud è già incluso (ksud + app/src/main/assets/ksud) quindi i passi 1–2 producono solo i due output NDK. Il target CMake in app/src/main/cpp/CMakeLists.txt può inoltre ricompilare libpreload.so dagli stessi sorgenti all'interno dell'APK come fallback.

Build on-device (Termux, aarch64)

aapt2/NDK dell'SDK sono x86_64 e non possono essere eseguiti on-device. Procedura verificata (SDK in ~/android-sdk, Gradle 8.9 - AGP 8.5.2 rifiuta il Gradle 9.x di sistema):

# Native payloads with the Termux toolchain (API 35 target, system liblog):
cd exploit
clang -O2 --target=aarch64-linux-android35 -fPIE -pie -Isrc src/su_daemon.c \
  -o build/embed/su_daemon_aarch64_pie
clang -O2 --target=aarch64-linux-android35 -fPIC -Isrc \
  -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-macro-redefined \
  src/main.c src/util.c src/bootclaim.c src/slide.c src/fops.c src/attr.c \
  src/root.c src/params.c src/params_table.c src/preload.c \
  -L/system/lib64 -llog -shared -o build/bin/preload.so
cd .. && ./stage-assets.sh

# APK (CMake native step auto-skips without SDK cmake; Termux aarch64 aapt2
# is injected via -P so checked-in files stay workstation-clean):
env ANDROID_HOME=~/android-sdk ANDROID_SDK_ROOT=~/android-sdk \
  JAVA_HOME=$PREFIX/lib/jvm/java-21-openjdk \
  ~/gradle-dists/gradle-8.9/bin/gradle :app:assembleDebug --console=plain \
  -Pandroid.aapt2FromMavenOverride=$(command -v aapt2)

Esecuzione

1. Installare l'APK sul dispositivo S26 + installare/avviare Shizuku (wireless debugging o PC).
2. Aprire GhostLock - il permesso Shizuku viene richiesto automaticamente all'avvio; approvarlo una volta (dura fino al riavvio del server Shizuku).
3. Verificare che la card Device indichi SUPPORTED/LIKELY per la propria build.
4. Toccare Stage, poi Run once. La race è probabilistica - usare Retry ×5; diversi tentativi sono normali.
5. Check root → ci si aspetta uid=0 …. Poi eseguire comandi nella card Root shell.
6. Dopo il successo, installare/usare KernelSU Manager (me.weishu.kernelsu); il demone carica automaticamente ksud in late-load (vedere la modalità K in su_daemon.c).

Shizuku è opzionale ma fortemente consigliato: il flusso upstream viene eseguito da una adb shell (uid 2000, contesto SELinux shell), e il fallback interno all'app (untrusted_app) ha molte più probabilità di essere bloccato su LD_PRELOAD/exec in /data/local/tmp.

Codici di uscita (mostrati dopo ogni tentativo)

Provenienza

• Exploit: exploit/ + PORTING.upstream.md + ksud da 1ndevelopment/ghostlock-s26 (Apache-2.0; vedere LICENSE.upstream, NOTICE.upstream). L'app non collega alcun codice dell'exploit nel proprio processo - prepara i file compilati con l'NDK e avvia la shell LD_PRELOAD documentata.
• Crediti (upstream): Nebula Security (scoperta della CVE), polygraphene (baseline), monovibe (UMH root / boot-claim), lukasmaar (kernelsnitch), veritas501 (concetto della pipe), BuSung-dev (base della companion-app).