Réécriture de corps

Chute peut rechercher et remplacer du contenu dans les corps de requête et de réponse HTTP à l'aide d'expressions régulières ou d'expressions JSONPath. Cela nécessite le déchiffrement MitM pour le trafic HTTPS.

Les règles de réécriture de corps sont définies dans la section [Body Rewrite]. Pour chaque direction (requête / réponse), seule la première règle correspondante est appliquée à un message.

[Body Rewrite]
^https://api\.example\.com/response.* response regex "old-text" "new-text"
^https://api\.example\.com/request.* request regex "sensitive" "[redacted]"
^https://api\.example\.com/data.* jsonpath-response jsonpath $.ads null

Format des règles

Chaque règle suit ce format général :

<regex d'URL> [direction] <mode> <motif> <remplacement>

Remarque : l'expression régulière d'URL doit correspondre à l'URL de requête complète, et non à une simple sous-chaîne. Les motifs devraient généralement se terminer par .* afin que les URL comportant n'importe quel chemin et n'importe quelle chaîne de requête soient prises en compte.

Direction

Modes

Mode regex

Effectue une recherche-remplacement regex standard sur le texte décodé du corps. Utilise NSRegularExpression (ICU) avec une correspondance insensible à la casse. Le remplacement prend en charge les références aux groupes de capture ($1, $2, etc.).

<regex d'URL> [response|request] regex <motif> <remplacement>

Exemple — supprimer les publicités d'une réponse JSON :

[Body Rewrite]
^https://api\.example\.com/feed.* response regex "\"ads\":\s*\[.*?\]" "\"ads\":[]"

Exemple — assainir le corps d'une requête :

[Body Rewrite]
^https://api\.example\.com/submit.* request regex "\"password\":\s*\".*?\"" "\"password\":\"[FILTERED]\""

Exemple — utiliser les groupes de capture pour reformater des données :

[Body Rewrite]
// Transforme "nom, prénom" en "prénom nom"
^https://api\.example\.com/users.* response regex "\"name\":\s*\"(\w+),\s*(\w+)\"" "\"name\":\"$2 $1\""

Exemple — réécrire les URL intégrées au corps de la réponse :

[Body Rewrite]
^https://api\.example\.com.* response regex "https://old-cdn\.example\.com" "https://new-cdn.example.com"

Les jetons contenant des espaces doivent être encadrés par des guillemets doubles :

[Body Rewrite]
^https://example\.com.* response regex "old value with spaces" "new value"

Pour inclure un guillemet double littéral dans un jeton entre guillemets, échappez-le par une barre oblique inverse : \".

Mode JSONPath

Modifie les corps JSON à l'aide d'expressions JSONPath. Prend en charge la lecture, la définition et la suppression de valeurs à des chemins précis.

<regex d'URL> jsonpath-response|jsonpath-request jsonpath <expression-jsonpath> [valeur]

Syntaxe JSONPath prise en charge

Types de valeur

Remarque : mettre une valeur entre guillemets ne force pas le type chaîne — les guillemets sont retirés lors de la tokenisation et le type est déduit du contenu restant : "42" devient donc le nombre 42 et "true" le booléen vrai. Le mot-clé nil est également accepté comme mot-clé de suppression, au même titre que null.

Exemple — définir un champ JSON :

[Body Rewrite]
^https://api\.example\.com/profile.* jsonpath-response jsonpath $.user.name "Anonymous"

Exemple — supprimer un champ JSON :

[Body Rewrite]
^https://api\.example\.com/data.* jsonpath-response jsonpath $.tracking null

Exemple — modification par joker :

[Body Rewrite]
^https://api\.example\.com/list.* jsonpath-response jsonpath $.items[*].hidden true

Exemples pratiques

Retirer les paramètres de suivi des réponses JSON

Supprimez le champ trackingId de toutes les réponses d'API. Comme une seule règle correspondante par direction est appliquée, utilisez une règle par motif d'URL :

[Body Rewrite]
^https://api\.example\.com/.* jsonpath-response jsonpath $.trackingId null

Injecter une balise script dans les réponses HTML

Ajoutez une balise <script> personnalisée avant </body> dans toutes les pages HTML :

[Body Rewrite]
^https://www\.example\.com/.* response regex "</body>" "<script>console.log('injected')</script></body>"

Masquer les champs sensibles dans les journaux de requêtes

Remplacez les clés d'API et les jetons dans les corps de requête sortants avant qu'ils n'atteignent le serveur. Comme une seule règle correspondante par direction est appliquée, combinez les deux champs dans une seule règle :

[Body Rewrite]
^https://api\.example\.com/.* request regex "\"(apiKey|token)\":\s*\"[^\"]+\"" "\"$1\":\"[REDACTED]\""

Normaliser les formats de date dans les réponses

Remplacez les dates ISO par un format plus court :

[Body Rewrite]
^https://api\.example\.com/.* response regex "(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z" "$1/$2/$3 $4:$5"

Désactiver les indicateurs de fonctionnalité dans la configuration d'une app

Forcez tous les indicateurs de fonctionnalité à false sur un point de terminaison de configuration :

[Body Rewrite]
^https://api\.example\.com/config.* jsonpath-response jsonpath $.features[*].enabled false

Réécrire les URL de CDN dans les réponses en cache

Remplacez toutes les références à un ancien CDN par un nouveau :

[Body Rewrite]
^https://www\.example\.com/.* response regex "https://old-cdn\.example\.com" "https://new-cdn.example.com"

Chaîne de traitement

La réécriture de corps gère automatiquement :

1. Content-Encoding : prend en charge gzip et deflate. Ignore les encodages non pris en charge.
2. Transfer-Encoding : dé-fragmente l'encodage de transfert par blocs avant traitement.
3. Décodage : décompresse les corps avant d'appliquer les règles de réécriture.
4. Réencodage : recompresse les corps et met à jour Content-Length. Supprime l'en-tête Transfer-Encoding.
5. Accept-Encoding : lorsqu'une règle de réponse correspond à l'URL d'une requête, l'en-tête Accept-Encoding de la requête est réécrit en gzip, deflate, identity afin que la réponse conserve un encodage décodable.

La taille maximale de corps pour le traitement de réécriture est de 128 Ko. Les corps plus volumineux sont transmis sans modification.

Remarques

• Pour le trafic HTTPS, le déchiffrement MitM doit être activé pour le nom d'hôte correspondant.
• La correspondance regex est insensible à la casse. Le modèle de remplacement prend en charge les références de groupe de capture ICU : $0 (correspondance complète), $1 (premier groupe), $2 (deuxième groupe), etc.
• Le mode JSONPath ne s'applique que si le corps est un JSON valide.
• Les règles de réécriture de corps sont appliquées au texte décodé (UTF-8) du corps.
• Seule la première règle correspondante par direction (requête / réponse) est appliquée à un message. Définissez une règle combinée si vous devez effectuer plusieurs modifications.
• Supprimer un JSONPath inexistant laisse le corps inchangé. Définir une valeur crée la clé lorsque son objet parent existe ; si un chemin intermédiaire est absent, rien ne se passe.