# Persistance des scripts Frida

FIRERPA vous offre la possibilité de rendre les scripts Frida persistants. Vous pouvez facilement injecter des scripts via les interfaces correspondantes, et le gestionnaire de scripts de FIRERPA s'occupera automatiquement de la gestion des scripts injectés. Même si votre script se termine de manière anormale ou si le processus de l'application se ferme, FIRERPA réinjectera automatiquement le script pour vous lors de la prochaine ouverture de votre application. Cette fonctionnalité a été introduite dans la version 7.80.

## Installer un script

Vous pouvez utiliser cette interface pour installer votre script dans une application cible. Le script que vous installez dans cette application sera injecté immédiatement après l'installation. Le script installé entrera automatiquement dans le gestionnaire de scripts, qui le surveillera et le réinjectera en permanence pour vous.

```{attention}
Le gestionnaire de scripts n'autorise l'injection que d'un seul script par application à la fois. Vous ne pouvez pas injecter plusieurs scripts dans la même application simultanément.
```

```python
app = d.application("com.android.settings")
app.attach_script(script, runtime=ScriptRuntime.RUNTIME_QJS, standup=5)
```

Le paramètre `script` est le contenu de votre script Frida à injecter (le bytecode est pris en charge). `runtime` est le runtime correspondant, par défaut `qjs`. Le paramètre `standup` signifie que l'injection ne se fera que 5 secondes après le démarrage du processus de l'application (le temps est calculé à partir de la création du processus). Ce paramètre a une valeur minimale de 1 seconde et maximale de 300 secondes, afin d'éviter des plantages ou d'autres problèmes de concurrence dus à une injection trop précoce dans le processus de l'application. En mode `spawn`, ce paramètre doit toujours être à 0.

Cette interface prend également en charge l'injection en mode `spawn`. Cependant, veuillez noter que l'utilisation du mode `spawn` peut interrompre votre flux d'opérations d'interface utilisateur (si vous devez également manipuler l'interface utilisateur), car une fois que vous utilisez le mode `spawn`, en cas de sortie anormale du script ou de fermeture de l'application, ce mode relancera automatiquement l'application, ce qui peut interférer avec vos opérations sur l'interface. Si vous devez utiliser le mode `spawn`, veuillez utiliser les paramètres suivants.

```python
app = d.application("com.android.settings")
app.attach_script(script, runtime=ScriptRuntime.RUNTIME_QJS, spawn=True, standup=0)
```

Il est important de noter la différence entre le mode `spawn` et le mode normal. En mode normal, si l'application se ferme pour une raison quelconque, le mode normal attendra que l'application soit démarrée pour effectuer l'injection et ne la démarrera pas de sa propre initiative. Il se peut donc que vous deviez démarrer l'application par code ou manuellement pour que l'injection se poursuive. En mode `spawn`, même si l'application se ferme, elle sera automatiquement démarrée et l'injection sera effectuée.

## Désinstaller un script

Cette interface supprimera le script Frida déjà installé dans l'application. Le script sera également détaché du processus de l'application, et le gestionnaire de scripts de FIRERPA ne surveillera plus l'état de santé de ce script et n'effectuera plus d'opérations de réinjection après une anomalie du script.

```python
app = d.application("com.android.settings")
app.detach_script()
```

## Vérifier si un script est installé

Cette interface est utilisée pour vérifier si un script a déjà été installé dans l'application. Vous pouvez utiliser cet état pour déterminer si une réinstallation est nécessaire.

```python
app = d.application("com.android.settings")
app.is_attached_script()
```

## Vérifier si un script est injecté

Cette interface est utilisée pour vérifier si le script que vous avez installé est actuellement injecté dans le processus de l'application. En effet, même si vous avez installé le script, il se peut qu'il ne soit pas injecté dans le processus de l'application parce que l'application n'a pas été démarrée ou à cause d'erreurs dans le script. Vous pouvez utiliser sa valeur de retour pour déterminer s'il faut démarrer l'application concernée ou vérifier s'il y a des erreurs de syntaxe dans le script d'injection.

```python
app = d.application("com.android.settings")
app.is_script_alive()
```

## Consulter les journaux du script

Les journaux de la console de votre script, tels que ceux générés par `console.log`, ainsi que les messages d'erreur du script peuvent être consultés. Cependant, vous devez le configurer à l'avance lors du démarrage. Veuillez consulter la section `Consulter les journaux` pour savoir comment configurer le fichier journal. Supposons que vous ayez correctement configuré le fichier journal comme étant `/data/local/tmp/server.log`. Ainsi, lorsque vous avez besoin de consulter les journaux du script, exécutez la commande suivante. Cela filtrera toutes les informations de journalisation des scripts injectés. Vous pouvez également utiliser d'autres commandes comme `tail -f` pour suivre les journaux en continu.

```bash
grep SCRIPT /data/local/tmp/server.log
```

## Persistance hors ligne

La persistance hors ligne signifie que vous pouvez placer votre script FRIDA sur le téléphone en tant que fichier de configuration, et FIRERPA chargera automatiquement votre script FRIDA au démarrage. Vous n'avez absolument pas besoin d'utiliser les interfaces API mentionnées ci-dessus pour effectuer des opérations d'injection, de suppression, etc. Il vous suffit de rédiger le fichier de script dans un format spécifique et de le placer dans un répertoire fixe. Cette fonctionnalité prend en charge la surveillance de répertoire, le chargement, le déchargement et la mise à jour des scripts en temps réel. Les modifications directes dans le répertoire des scripts seront également appliquées en temps réel. Voici une configuration simple de persistance de script YAML. Le contenu du script dans la configuration ci-dessous est `console.log("Hello From Yaml Script")`.

```yaml
enable: true
application: "com.android.settings"
version: "2.10"
user: 0
runtime: "qjs"
script: !!binary "Y29uc29sZS5sb2coIkhlbGxvIEZyb20gWWFtbCBTY3JpcHQiKQ=="
emit: "http://myserver/reportData"
encode: "none"
standup: 10
spawn: false
```

Explication détaillée de chaque champ de configuration dans l'exemple de script ci-dessus

| Champ       | Description                                                                |
|------------|---------------------------------------------------------------------|
| enable     | S'il faut activer ce script                                                       |
| application| L'ID de l'application dans laquelle injecter le script (ex: com.android.setting)                           |
| version    | La version de l'application prise en charge par le script ("N/A" signifie toutes les versions)                        |
| user       | S'il s'agit d'une application multi-instance, spécifiez l'ID utilisateur de l'application clonée (généralement 999)              |
| script     | Contenu du script en base64, supporte le texte ou le binaire (veuillez suivre le modèle) |
| runtime    | Le runtime du script (qjs, v8)                                                      |
| standup    | Le délai d'injection (calculé à partir du démarrage du processus)                                 |
| spawn      | Utiliser le mode spawn (ignorera `standup`)                                 |
| encode     | Si le script envoie des données, spécifiez l'encodage ici (zlib/none)                     |
| emit       | Si le script envoie des données, spécifiez la destination ici                                   |

Pour plus d'informations sur la fonctionnalité d'envoi de données `emit`, veuillez consulter la section `Utiliser Frida pour rapporter des données`.

Ce qui précède est un exemple complet de script hors ligne. Une fois rédigé, veuillez enregistrer le fichier de configuration avec le nom `{file_name}.yaml` et le placer dans le dossier `/data/usr/modules/script` de l'appareil. Le système chargera automatiquement votre configuration. Le système détectera automatiquement les modifications dans le répertoire `/data/usr/modules/script`. Si vous mettez à jour ou supprimez la configuration YAML, le système mettra également à jour ou annulera automatiquement l'injection de votre script.