GhostLock - Wrapper Android (indev.ghostlock.s26)

Wrapper Android en un clic pour 1ndevelopment/ghostlock-s26 : GhostLock (CVE-2026-43499) porté sur toute la série Samsung Galaxy S26 (Android 16 / GKI 6.12). Un seul APK, trois lignes de noyau, correspondance des paramètres à l'exécution - aucune variante d'application par build.

À utiliser uniquement sur des appareils que vous possédez ou que vous êtes explicitement autorisé à tester. Le root temporaire disparaît au redémarrage. Une seconde exécution de l'exploit dans le même démarrage peut faire planter l'appareil - redémarrez avant de réessayer.

Couverture : toute la famille S26

L'exploit correspond par ligne de noyau, pas par build individuel (exploit/src/params_table.c fait autorité ; ParamsTable.kt le reflète uniquement pour le verdict de l'interface) :

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

Les OTA inconnues se rabattent exactement comme le params.c amont : d'abord le build exact, puis même modèle + CSC à 3 caractères (réutilisation OTA), puis la dernière entrée du même appareil (marquée non vérifiée), sinon échec fermé (l'application affiche UNSUPPORTED et la couche native se termine avec le code 2). Les modèles totalement inconnus sont refusés - jamais forcés.

Ce que fait l'application

Un grand bouton - Root my S26 - exécute tout le pipeline et raconte le déroulement dans la carte Output :

1. Vérification de l'appareil - modèle/device/incremental/fingerprint ainsi que le verdict de la série (exact / réutilisation OTA / estimation non vérifiée / non supporté). Les builds non supportés s'arrêtent ici (échec fermé, aucune boot-claim consommée).
2. Shizuku - utilisé automatiquement lorsqu'il est connecté (uid 2000 shell, même famille de contexte que le flux adb shell du README). La permission est demandée une fois au lancement (et de nouveau si le serveur redémarre) ; le flux Root attend l'octroi au lieu d'abandonner. Si le serveur est arrêté, l'application ouvre le gestionnaire Shizuku pour que vous puissiez le démarrer, puis se rabat sur le shell intégré. Ajouter l'application à la liste d'autorisation de Shizuku supprime entièrement l'invite.
3. Stage - copie preload.so, su_daemon, ksud vers /data/local/tmp (preload.so, cve-2026-43499-root, ksud) et leur applique chmod. Si vous avez déjà adb push les fichiers selon le README amont, ils sont récupérés sur place.
4. Run - exécute exactement ce que documente l'amont : (le constructeur du exécute la chaîne et fait ; stdout le journal de l'exploit), jusqu'à 5 tentatives - la course est probabiliste. Un commutateur est disponible mais redémarrer est plus sûr.

En dessous : une seule ligne champ de commande + Run as root (commandes one-shot via le protocole C du démon su ; le PTY interactif est hors périmètre pour la v1), et un petit lien Reset qui efface /data/local/tmp/ghostlock-boot.log afin qu'une exécution puisse être retentée sans redémarrer (l'amont avertit que cela peut provoquer un panic - redémarrer est la voie sûre).

Structure du projet

exploit/                  vendored upstream (Makefile + src/, authoritative)
ksud                      upstream prebuilt KernelSU loader (ARM64 PIE, also in assets)
app/src/main/assets/ksud  staged copy shipped in the APK
app/src/main/assets/      + preload.so / su_daemon after stage-assets.sh
app/src/main/cpp/         optional CMake rebuild of preload.so from exploit/src
app/src/main/java/indev/ghostlock/s26/
  MainActivity.kt         UI (device / stage / run / shell / boot guard)
  ParamsTable.kt          series table mirror (17 builds, 3 lines, 5 codenames)
  DeviceCompat.kt         Build.* identity + series verdict
  ShellRunner.kt          Shizuku (uid 2000) + local fallback, staging
  SuClient.kt             /data/local/tmp/temp_su.sock 'C'-mode client
  GhostlockManager.kt     exit-code interpreter (0/1/2/3/4)
PORTING.upstream.md       porting notes (new firmware = new device_map row)

Compilation

Prérequis : 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 est déjà vendored (ksud + app/src/main/assets/ksud) donc les étapes 1–2 ne produisent que les deux sorties NDK. La cible CMake dans app/src/main/cpp/CMakeLists.txt peut en outre reconstruire libpreload.so à partir des mêmes sources à l'intérieur de l'APK comme solution de repli.

Compilation sur l'appareil (Termux, aarch64)

Les aapt2/NDK du SDK sont x86_64 et ne peuvent pas s'exécuter sur l'appareil. Procédure vérifiée (SDK à ~/android-sdk, Gradle 8.9 - AGP 8.5.2 rejette le Gradle 9.x du système) :

# 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)

Exécution

1. Installez l'APK sur l'appareil S26 + installez/démarrez Shizuku (débogage sans fil ou PC).
2. Ouvrez GhostLock - la permission Shizuku est demandée automatiquement au lancement ; approuvez-la une fois (elle dure jusqu'au redémarrage du serveur Shizuku).
3. Vérifiez que la carte Device indique SUPPORTED/LIKELY pour votre build.
4. Appuyez sur Stage, puis Run once. La course est probabiliste - utilisez Retry ×5 ; plusieurs tentatives sont normales.
5. Check root → attendez-vous à uid=0 …. Exécutez ensuite des commandes dans la carte Root shell.
6. Après succès, installez/utilisez KernelSU Manager (me.weishu.kernelsu) ; le démon charge ksud tardivement et automatiquement (voir le mode K de su_daemon.c).

Shizuku est optionnel mais fortement recommandé : le flux amont s'exécute depuis un adb shell (uid 2000, contexte SELinux shell), et le repli intégré à l'application (untrusted_app) a bien plus de chances d'être bloqué pour LD_PRELOAD/exec sur /data/local/tmp.

Codes de sortie (affichés après chaque tentative)

Provenance

• Exploit : exploit/ + PORTING.upstream.md + ksud depuis 1ndevelopment/ghostlock-s26 (Apache-2.0 ; voir LICENSE.upstream, NOTICE.upstream). L'application ne lie aucun code d'exploit dans son propre processus - elle stage les fichiers compilés avec le NDK et lance le shell LD_PRELOAD documenté.
• Crédits (amont) : Nebula Security (découverte de la CVE), polygraphene (baseline), monovibe (UMH root / boot-claim), lukasmaar (kernelsnitch), veritas501 (concept du pipe), BuSung-dev (base de l'application compagnon).