xnuspy

^{Sortie du journal du noyau après compilation et exécution de example/open1_hook.c}

xnuspy est un module pongoOS qui installe un nouvel appel système, xnuspy_ctl, permettant de hooker des fonctions du noyau depuis l'espace utilisateur. Il supporte iOS 13.x, iOS 14.x et iOS 15.x sur checkra1n 0.12.2 et ultérieur. Les appareils 4K ne sont pas supportés.

Ce module neutralise complètement KTRR/KPP et permet de créer de la mémoire RWX dans EL1. Ne l'utilisez pas sur votre appareil principal.

Nécessite libusb : brew install libusb

Construction

Exécutez make dans le répertoire racine. Cela compilera le chargeur et le module.

Options de construction

Ajoutez-les avant make.

• XNUSPY_DEBUG=1
  • Envoie les sorties de débogage de xnuspy vers le journal du noyau (kprintf).
• XNUSPY_SERIAL=1
  • Envoie les sorties de débogage de xnuspy vers IOLog.
• XNUSPY_LEAKED_PAGE_LIMIT=n
  • Définit le nombre de pages que xnuspy peut fuir avant que son thread de collecte des ordures ne commence à les désallouer. La valeur par défaut est 64. Plus d'informations se trouvent sous Débogage des paniques du noyau.
• XNUSPY_TRAMP_PAGES=n
  • Définit le nombre de pages que xnuspy réserve pour ses structures de trampoline. La valeur par défaut est 1. Plus d'informations se trouvent sous Limites.

XNUSPY_DEBUG et XNUSPY_SERIAL ne dépendent pas l'un de l'autre.

Utilisation

Après avoir tout construit, faites démarrer votre appareil par checkra1n dans un shell pongo : /Applications/checkra1n.app/Contents/MacOS/checkra1n -p

Dans le même répertoire où vous avez construit le chargeur et le module, faites loader/loader module/xnuspy. Après cela, xnuspy fera son travail et dans quelques secondes votre appareil démarrera. loader attendra quelques secondes supplémentaires après avoir émis xnuspy-getkernelv au cas où SEPROM doit être exploitée.

Problèmes connus

Parfois, certains de mes téléphones restaient bloqués sur « Booting » après l'exécution du KPF de checkra1n. Je n'ai pas encore compris ce qui cause cela, mais si cela arrive, réessayez. De plus, si l'appareil se bloque après bootx, réessayez. Enfin, marquer le code compilé xnuspy_ctl comme exécutable sur mon iPhone X sous iOS 13.3.1 est un peu capricieux, mais réussit 100% du temps sur mes autres téléphones. Si vous paniquez avec un abandon de récupération d'instruction du noyau lorsque vous exécutez votre programme de hook, réessayez.

xnuspy_ctl

xnuspy va patcher un appel système enosys pour pointer vers xnuspy_ctl_tramp. C'est un petit trampoline qui marque le code compilé xnuspy_ctl comme exécutable et saute vers lui. Vous trouverez l'implémentation de xnuspy_ctl dans module/el1/xnuspy_ctl/xnuspy_ctl.c et des exemples dans le répertoire example.

À l'intérieur de include/xnuspy/ se trouve xnuspy_ctl.h, un en-tête qui définit des constantes pour xnuspy_ctl. Il est destiné à être inclus dans tous les programmes qui hookent des fonctions du noyau.

Vous pouvez utiliser sysctlbyname pour savoir quel appel système a été patché :``` size_t oldlen = sizeof(long); long SYS_xnuspy_ctl = 0; sysctlbyname("kern.xnuspy_ctl_callnum", &SYS_xnuspy_ctl, &oldlen, NULL, 0);

Cet appel système prend quatre arguments : `flavor`, `arg1`, `arg2` et `arg3`.
Les saveurs possibles sont `XNUSPY_CHECK_IF_PATCHED`, `XNUSPY_INSTALL_HOOK`,
`XNUSPY_REGISTER_DEATH_CALLBACK`, `XNUSPY_CALL_HOOKME`, `XNUSPY_CACHE_READ`,
`XNUSPY_KREAD`, `XNUSPY_KWRITE` ou `XNUSPY_GET_CURRENT_THREAD`.
La signification des trois arguments suivants dépend de la saveur.

## `XNUSPY_CHECK_IF_PATCHED`
Cette saveur existe pour que vous puissiez vérifier si `xnuspy_ctl` est présent. L'invoquer avec cette saveur lui fera retourner `999`. Les valeurs des autres arguments sont ignorées.

## `XNUSPY_INSTALL_HOOK`
J'ai conçu cette saveur pour correspondre à l'API de [`MSHookFunction`](http://www.cydiasubstrate.com/api/c/MSHookFunction/).
`arg1` est l'adresse *NON GLISSÉE* de la fonction du noyau que vous souhaitez hooker. Si vous fournissez une adresse glissée, vous provoquerez très probablement un kernel panic. `arg2` est un pointeur vers votre fonction de remplacement compatible ABI. `arg3` est un pointeur pour que `xnuspy_ctl` fasse `copyout` de l'adresse d'un trampoline qui représente la fonction originale du noyau. Cela peut être `NULL` si vous n'avez pas l'intention d'appeler l'originale.

## `XNUSPY_REGISTER_DEATH_CALLBACK`
Cette saveur vous permet d'enregistrer un « callback de fin de vie » optionnel, une fonction que xnuspy appellera lorsque votre programme de hook se termine. Cela vous donne la possibilité de nettoyer tout ce que vous avez créé à partir de vos hooks du noyau. Si vous avez créé des threads noyau, vous leur demanderiez de se terminer dans cette fonction.

Votre callback n'est pas invoqué de manière asynchrone, donc si vous bloquez, vous empêchez le thread de garbage collection de xnuspy de s'exécuter.

`arg1` est un pointeur vers votre fonction callback. Les valeurs des autres arguments sont ignorées.

## `XNUSPY_CALL_HOOKME`
`hookme` est un petit stub assembleur que xnuspy exporte via le cache xnuspy pour que vous puissiez le hooker. Invoquer `xnuspy_ctl` avec cette saveur entraînera l'appel de `hookme`, offrant un moyen d'obtenir facilement une exécution de code noyau sans avoir à hooker une fonction noyau réelle.

`arg1` est un argument qui sera passé à `hookme` lors de son invocation. Cela peut être `NULL`.

## `XNUSPY_CACHE_READ`
Cette saveur vous offre un moyen de lire depuis le cache xnuspy. Il contient de nombreuses choses utiles comme `kprintf`, `current_proc`, `kernel_thread_start`, certaines fonctions libc, et le slide du noyau afin que vous n'ayez pas à les trouver vous-même. Pour une liste complète des identifiants de cache, consultez `example/xnuspy_ctl.h`. 

`arg1` est l'un des identifiants de cache définis dans `xnuspy_ctl.h` et `arg2` est un pointeur pour que `xnuspy_ctl` fasse `copyout` de l'adresse ou de la valeur de ce que vous avez demandé. Les valeurs des autres arguments sont ignorées.

## `XNUSPY_KREAD`
Cette saveur vous offre un moyen simple de lire la mémoire du noyau depuis l'espace utilisateur sans tfp0.

`arg1` est une adresse virtuelle noyau, `arg2` est l'adresse d'un tampon espace utilisateur, et `arg3` est la taille de ce tampon espace utilisateur. `arg3` octets seront écrits de `arg1` vers `arg2`.

## `XNUSPY_KWRITE`
Cette saveur vous offre un moyen simple d'écrire dans la mémoire du noyau depuis l'espace utilisateur sans tfp0.

`arg1` est une adresse virtuelle noyau, `arg2` est l'adresse d'un tampon espace utilisateur, et `arg3` est la taille de ce tampon espace utilisateur. `arg3` octets seront écrits de `arg2` vers `arg1`.

## `XNUSPY_GET_CURRENT_THREAD`
Cette saveur fournit à l'espace utilisateur l'adresse noyau du thread appelant.

`arg1` est un pointeur pour que `xnuspy_ctl` fasse `copyout` de la valeur de retour de `current_thread`. Les valeurs des autres arguments sont ignorées.

### Errors
Pour toutes les saveurs sauf `XNUSPY_CHECK_IF_PATCHED`, `0` est retourné en cas de succès. En cas d'erreur, `-1` est retourné et `errno` est défini. `XNUSPY_CHECK_IF_PATCHED` ne retourne aucune erreur. La fonction `mach_to_bsd_errno` de XNU est utilisée pour convertir un `kern_return_t` en `errno` approprié.