Introduction : pourquoi un testeur a besoin de son propre proxy entre l'application et le serveur

Imaginez : vous testez une application mobile, vous appuyez sur un bouton, et à l'écran apparaît une erreur abstraite « Une erreur est survenue ». Le développeur demande : « Quelle requête est partie ? Quelle réponse est revenue ? Quel code de statut ? ». Sans proxy, vous restez les bras ballants. Avec un proxy, vous ouvrez la liste des requêtes, vous copiez le corps de la réponse du serveur et vous l'ajoutez au bug en trente secondes. C'est exactement la différence entre un testeur qui « clique » et un testeur qui comprend ce qui se passe sous le capot.

Cet article se démarque volontairement des tutoriels grand public qui expliquent comment saisir une adresse de proxy dans les réglages Wi-Fi du téléphone. Ici, on décortique le flux de travail d'un ingénieur QA : un proxy d'interception sur l'ordinateur, rediriger vers lui le trafic de l'émulateur Android, connecter un appareil réel en Wi-Fi et en USB via un tunnel de port avec la commande adb reverse, ainsi qu'intercepter et modifier le trafic de l'environnement de test. La configuration du proxy sur le téléphone côté utilisateur n'est qu'une petite brique dans ce processus.

Ce que vous obtiendrez au final

  • Un proxy d'interception fonctionnel (mitmproxy ou Charles) qui affiche chaque requête HTTP et HTTPS de votre application.
  • Un émulateur Android dont le trafic passe par ce proxy, y compris le trafic chiffré.
  • Un vrai smartphone connecté au proxy de deux façons : en Wi-Fi et par câble USB via adb reverse.
  • La compréhension de pourquoi l'application « ne fait pas confiance » au certificat et comment résoudre ça sur une build de test.
  • La capacité de modifier les réponses de l'environnement de test, de simuler un réseau lent et des erreurs serveur sans solliciter un développeur back-end.

À qui s'adresse ce guide

Aux testeurs manuels et automatiseurs d'applications mobiles qui veulent voir le trafic réseau plutôt que deviner. Aux juniors à qui, lors d'un nouveau poste, on a dit « regarde dans Charles » sans expliquer ni ce que c'est ni comment ça marche. Aux développeurs qui configurent l'environnement de test pour leur équipe.

Ce qu'il faut savoir au préalable

Une compréhension de base de ce qu'est une requête HTTP, une réponse, un code de statut 200 et 500. Savoir ouvrir un terminal ou une ligne de commande et y exécuter une commande. Une expérience d'installation d'applications sur Android. Si vous n'avez jamais lancé d'émulateur — pas de panique, on va parcourir ce chemin ensemble.

Combien de temps cela prendra

Avec une bonne connexion internet et Android Studio déjà installé — entre une heure et demie et deux heures pour l'ensemble du guide. Si Android Studio n'est pas encore installé, ajoutez 30 à 60 minutes pour télécharger les images système. Après la première fois, reconfigurer le tout sur un nouveau projet prend environ dix minutes.

Préparation : outils, accès et prérequis système

Ce qu'il faut installer sur l'ordinateur

  1. Android Studio en version actuelle 2025-2026. Il installe avec lui le SDK Android, l'émulateur Android et l'utilitaire adb. C'est la boîte à outils principale.
  2. Un proxy d'interception. Le guide présente deux options : mitmproxy, gratuit (utilisable en terminal ou via l'interface web mitmweb) et Charles Proxy, commercial avec un mode d'essai gratuit. Choisissez-en un, vous pourrez apprendre l'autre plus tard. Toutes les instructions sont données pour les deux.
  3. Java n'est pas nécessaire séparément : Android Studio utilise un JDK intégré.
  4. Une build de test de l'application au format APK. Il doit s'agir d'une build debug ou d'une build QA dédiée, pas d'une release du store. Pourquoi c'est crucial — on l'expliquera dans la partie sur les certificats.

Prérequis système

  • Système d'exploitation : Windows 10 ou 11 (64-bit), macOS 12 ou plus récent, Linux avec support KVM.
  • Mémoire vive : au minimum 8 Go, 16 Go pour être confortable. L'émulateur consomme à lui seul 2 à 4 Go.
  • Espace disque libre : au moins 20 Go. Une image système Android pèse 1,5 à 2 Go, sans compter Android Studio.
  • Virtualisation matérielle activée dans le BIOS/UEFI (Intel VT-x ou AMD-V). Sans elle, l'émulateur sera d'une lenteur insupportable ou ne démarrera pas.
  • Un appareil Android réel en version 8 ou supérieure et un câble USB pour le transfert de données (pas seulement pour la charge).

Les accès à demander à votre équipe

  • L'adresse de l'environnement de test (par exemple https://api-stage.example-team.ru) et les identifiants de test.
  • La build debug de l'application ou une build avec le flag « QA build ». Demandez aux développeurs si elle fait confiance aux certificats utilisateur et si le certificate pinning y est désactivé.
  • Si l'environnement est restreint par IP ou nécessite une connexion au réseau d'entreprise — voyez avec l'administrateur comment vous y connecter depuis votre poste. Nous n'envisageons aucun moyen de contourner les restrictions : uniquement les accès légitimes fournis par votre équipe.

Sauvegardes et sécurité

Les réglages de proxy dans l'émulateur et sur l'appareil sont entièrement réversibles. Avant de commencer, deux choses s'imposent toutefois. D'abord, si votre vrai téléphone a déjà des réglages Wi-Fi ou des certificats en place, faites des captures d'écran des menus de réglages — vous pourrez ainsi tout remettre en l'état rapidement. Ensuite, mieux vaut utiliser un appareil de test dédié plutôt que votre téléphone personnel avec des applications bancaires : le certificat racine du proxy donne à son détenteur la possibilité de lire le trafic chiffré. Sur un appareil de test, c'est normal, sur un appareil personnel, c'est un risque.

Attention : n'installez jamais le certificat racine d'un proxy d'interception sur un appareil personnel où se trouvent des applications bancaires et de paiement, et ne transmettez pas le fichier de clé privée du proxy à vos collègues via des messageries. Le certificat est généré localement sur votre ordinateur et doit y rester.

Notions de base : comment fonctionne l'interception du trafic

Qu'est-ce qu'un proxy d'interception

Un proxy classique est un intermédiaire qui reçoit une requête du client et la transmet au serveur. Un proxy d'interception (aussi appelé proxy de débogage ou man-in-the-middle) fait la même chose, mais conserve en plus une copie de chaque requête et de chaque réponse, vous les affiche de façon lisible et permet de les arrêter, les modifier et les substituer. Pour un testeur, c'est comme une radiographie pour un médecin.

Pourquoi le HTTPS n'est pas visible comme ça

Presque tout le trafic moderne est chiffré avec le protocole TLS. Le proxy voit que le téléphone s'est connecté au serveur api-stage.example-team.ru, mais le contenu des requêtes n'est pour lui qu'un flux chiffré. Pour déchiffrer, le proxy génère son propre certificat racine (CA) et émet à la volée de faux certificats pour chaque site. Le téléphone doit faire confiance à ce certificat racine — sinon l'application détectera la substitution et coupera la connexion avec une erreur du type « Trust anchor for certification path not found ». C'est pourquoi l'installation du certificat du proxy sur l'appareil est une étape obligatoire.

Certificats utilisateur et certificats système sur Android

À partir d'Android 7, les applications ne font confiance par défaut qu'aux certificats système et ignorent ceux installés par l'utilisateur via les réglages. Chrome fait exception, il accepte les certificats utilisateur. Pour que votre application fasse confiance au certificat du proxy, les développeurs disposent de deux voies légitimes : soit ajouter dans la build debug un fichier network_security_config.xml autorisant la confiance aux certificats utilisateur, soit installer le certificat en tant que certificat système sur un émulateur avec droits root. La première voie est plus simple et plus adaptée au travail en équipe.

Certificate pinning

Certaines applications « épinglent » en plus un certificat précis du serveur et refusent de fonctionner avec n'importe quel autre, même de confiance. C'est une bonne protection en production, mais pour les tests sur l'environnement de test, le pinning est généralement désactivé dans les builds debug. Si après toute la configuration l'application ne passe toujours pas par le proxy, demandez explicitement aux développeurs s'il s'agit du pinning.

Comment l'émulateur voit votre ordinateur

L'émulateur Android est une machine virtuelle dotée de son propre réseau. À l'intérieur, l'adresse 127.0.0.1 désigne l'émulateur lui-même, pas votre ordinateur. Pour joindre l'ordinateur depuis l'émulateur, on utilise l'adresse spéciale 10.0.2.2. Retenez-la — elle réapparaîtra dans les commandes ci-dessous.

Qu'est-ce qu'adb et adb reverse

adb (Android Debug Bridge) est un utilitaire en ligne de commande qui pilote un appareil Android depuis l'ordinateur : installer des applications, exécuter des commandes, faire des tunnels de ports. La commande adb reverse fait en sorte qu'un port sur l'appareil « pointe » vers un port de votre ordinateur. Par exemple, après adb reverse tcp:8080 tcp:8080, une application sur le téléphone qui contacte localhost:8080 atteindra en réalité le port 8080 de l'ordinateur, là où le proxy écoute. Cela fonctionne par USB, sans nécessiter de réseau Wi-Fi commun et sans dépendre des restrictions d'un point d'accès d'entreprise. La commande inverse, adb forward, fonctionne dans l'autre sens : un port de l'ordinateur pointe vers l'appareil. Ne les confondez pas.

L'environnement de test

L'environnement de test (stage, staging, environnement de dev) est une copie de la partie serveur de l'application destinée aux tests. Sur cet environnement, on peut casser des données, substituer des réponses et consulter les logs. L'application bascule généralement vers cet environnement soit via une build dédiée, soit via un menu caché. Toute l'interception du trafic se fait précisément avec cet environnement, pas avec la production.

Étape 1 : monter un proxy d'interception sur l'ordinateur

Objectif de l'étape : un proxy fonctionne sur l'ordinateur, écoute un port (8080 pour mitmproxy ou 8888 pour Charles) et vous connaissez l'adresse IP de l'ordinateur sur le réseau local.

Option A : mitmproxy

  1. Téléchargez l'installeur mitmproxy pour votre OS sur le site officiel du projet, ou installez-le via un gestionnaire de paquets. Sur macOS, Homebrew est pratique, sur Windows l'installeur .msi, sur Linux via pipx ou une archive binaire.
  2. Ouvrez un terminal (sous Windows — PowerShell ou Windows Terminal).
  3. Lancez la version web avec la commande :
    mitmweb --listen-port 8080
    Le terminal affichera des lignes indiquant le démarrage du proxy sur le port 8080, et une fenêtre de navigateur s'ouvrira sur l'interface web à l'adresse 127.0.0.1:8081. C'est là que les requêtes apparaîtront.
  4. Attention : l'interface mitmweb tourne sur le port 8081, tandis que le proxy lui-même écoute sur 8080. Dans les réglages des appareils, vous indiquez toujours 8080.
  5. Au premier lancement, mitmproxy crée un dossier .mitmproxy dans le répertoire personnel de l'utilisateur. Il contient le fichier mitmproxy-ca-cert.cer — c'est le certificat racine que nous installerons plus tard sur les appareils.

Astuce : si vous voulez travailler entièrement en terminal sans navigateur, lancez la commande mitmproxy au lieu de mitmweb. L'interface sera en console : flèches pour naviguer, Entrée pour ouvrir une requête, q pour revenir. Pour l'automatisation, il y a mitmdump, qui écrit le flux dans un fichier.

Option B : Charles Proxy

  1. Téléchargez Charles depuis le site officiel, installez-le et lancez-le. La fenêtre principale apparaît avec une liste vide à gauche et les onglets Overview, Contents à droite.
  2. Ouvrez le menu Proxy → Proxy Settings. Dans l'onglet Proxies, vérifiez que le port est 8888 et que la case « Enable transparent HTTP proxying » est décochée. Cliquez sur OK.
  3. Ouvrez Proxy → SSL Proxying Settings. Cochez Enable SSL Proxying. Dans le bloc Include, cliquez sur Add et ajoutez l'hôte * avec le port 443. Ainsi Charles déchiffrera tout le HTTPS. Vous pourrez plus tard restreindre la liste au domaine de l'environnement de test.
  4. Si Charles propose de configurer le proxy système de macOS ou Windows, refusez : nous voulons le trafic du téléphone, pas celui du navigateur de l'ordinateur. On peut le désactiver via le menu Proxy en décochant macOS Proxy ou Windows Proxy.

Connaître l'adresse IP de l'ordinateur

Pour un appareil réel en Wi-Fi, l'adresse de l'ordinateur sur le réseau local sera nécessaire.

  1. Windows : dans PowerShell, exécutez ipconfig et repérez la ligne « Adresse IPv4 » de l'adaptateur actif Wi-Fi ou Ethernet. C'est souvent quelque chose comme 192.168.1.45.
  2. macOS : Réglages Système → Réseau → sélectionnez la connexion active, l'adresse est affichée dans les détails. Ou dans le terminal ipconfig getifaddr en0.
  3. Linux : la commande ip addr show ou hostname -I.

Notez cette adresse. Dans la suite du texte, nous l'appellerons conventionnellement 192.168.1.45, remplacez par la vôtre.

Ouvrir le port dans le pare-feu

Windows demandera au premier lancement de mitmproxy ou Charles s'il faut autoriser le programme à accepter des connexions. Autorisez impérativement pour les réseaux privés. Si la fenêtre n'est pas apparue, ouvrez « Pare-feu Windows Defender → Autoriser une application » et ajoutez le programme manuellement. Sur macOS, l'autorisation est demandée de la même manière à la première connexion entrante.

Vérification : ouvrez un navigateur sur l'ordinateur, indiquez temporairement dans ses réglages le proxy 127.0.0.1 et le port 8080 (ou 8888), puis visitez un site. Des lignes de requêtes doivent apparaître dans mitmweb ou Charles. Après vérification, retirez le proxy du navigateur pour qu'il ne gêne pas. Alternative sans configurer le navigateur — la commande :

curl -x http://127.0.0.1:8080 -k https://example.com
Si une ligne avec example.com apparaît dans l'interface du proxy, le proxy fonctionne.

Problèmes possibles à cette étape

  • Port déjà utilisé. Message du type « Address already in use ». Un autre processus écoute déjà sur 8080 — souvent un environnement local ou un autre outil. Lancez le proxy sur un autre port, par exemple 8082, et utilisez-le partout ensuite.
  • mitmweb n'ouvre pas le navigateur. Ouvrez manuellement l'adresse 127.0.0.1:8081. L'adresse avec le token est affichée dans le terminal, copiez-la en entier.
  • Charles n'affiche pas le contenu HTTPS, seulement les en-têtes CONNECT. SSL Proxying n'est pas activé ou l'hôte n'est pas ajouté à Include. Revenez au point 3 de l'option B.

Étape 2 : diriger le trafic de l'émulateur Android vers le proxy

Objectif de l'étape : l'émulateur lancé envoie toutes ses requêtes HTTP et HTTPS vers votre proxy, et vous les voyez dans l'interface.

Créer et lancer l'émulateur

  1. Ouvrez Android Studio. Si aucun projet n'est ouvert, sur l'écran d'accueil choisissez More Actions → Virtual Device Manager. Dans un projet : menu Tools → Device Manager.
  2. Cliquez sur le bouton de création d'appareil (plus ou Create Virtual Device).
  3. Choisissez un modèle, par exemple Pixel 8, puis Next.
  4. Choisissez une image système. Important : pour les tests via proxy, une image marquée Google APIs est plus pratique qu'une image Google Play. Les images Google Play ont l'accès root bloqué, vous ne pourrez pas installer de certificat système en cas de besoin. Pour Android 14-16, ces images s'appellent par exemple « Android 15.0 Google APIs x86_64 » (sur ordinateurs à processeur Apple — arm64-v8a). Si une flèche de téléchargement est à côté de l'image — téléchargez-la, cela prendra 5 à 15 minutes.
  5. Sur le dernier écran, donnez à l'appareil un nom sans espaces, par exemple Pixel_8_QA, puis Finish.
  6. Lancez l'émulateur avec le bouton triangle. Le premier démarrage prend 1 à 3 minutes.

Méthode 1 : configuration via le panneau de l'émulateur (la plus simple)

  1. Dans la fenêtre de l'émulateur lancé, repérez la barre verticale à droite. Cliquez sur les trois points en bas — la fenêtre Extended Controls s'ouvre.
  2. Dans le menu de gauche, choisissez Settings, puis l'onglet Proxy.
  3. Décochez « Use Android Studio HTTP proxy settings ».
  4. Choisissez Manual proxy configuration.
  5. Dans le champ Host name, saisissez 127.0.0.1. Ici, contrairement aux réglages à l'intérieur d'Android, l'émulateur applique le proxy au niveau de la machine hôte, donc l'adresse de l'ordinateur est indiquée comme 127.0.0.1.
  6. Dans le champ Port number, saisissez 8080 (pour Charles — 8888).
  7. Cliquez sur Apply. En dessous, un statut « Proxy status: Success » doit apparaître. Si Error est affiché — le proxy n'est pas lancé ou le port est incorrect.

Méthode 2 : configuration via adb (flexible, adaptée aux scripts)

  1. Ouvrez un terminal. Assurez-vous qu'adb est disponible : la commande adb devices doit afficher une ligne du type emulator-5554 device. Si la commande n'est pas trouvée, ajoutez au PATH le dossier platform-tools dans le SDK Android (chemin visible dans Android Studio : Settings → Languages and Frameworks → Android SDK).
  2. Exécutez :
    adb shell settings put global http_proxy 10.0.2.2:8080
    Ici, nous sommes déjà « à l'intérieur » d'Android, c'est pourquoi l'ordinateur y est désigné par l'adresse 10.0.2.2.
  3. Vérifiez que le réglage a été appliqué :
    adb shell settings get global http_proxy
    Il doit retourner 10.0.2.2:8080.
  4. Pour désactiver le proxy, exécutez :
    adb shell settings put global http_proxy :0

Méthode 3 : paramètre en ligne de commande au démarrage

Si vous lancez l'émulateur depuis le terminal (par exemple en CI ou dans des scripts), ajoutez le flag :

emulator -avd Pixel_8_QA -http-proxy http://127.0.0.1:8080

L'exécutable emulator se trouve dans le dossier emulator du SDK Android. Le proxy s'appliquera à toute la session de l'émulateur.

Astuce : créez deux petits scripts — proxy_on et proxy_off — avec les commandes adb de la méthode 2. Dans une journée de test, vous activerez et désactiverez le proxy des dizaines de fois, et les clics dans les menus deviennent vite fatigants.

Vérifier que le trafic passe

  1. Dans l'émulateur, ouvrez le navigateur Chrome et allez sur n'importe quel site HTTPS.
  2. Des requêtes doivent apparaître dans mitmweb ou Charles. La page dans Chrome affichera probablement une erreur de sécurité — c'est normal, le certificat n'est pas encore installé. L'essentiel est que les requêtes soient visibles sous forme d'entrées avec un hôte et une méthode CONNECT.

Vérification : des lignes avec le domaine du site que vous avez ouvert dans l'émulateur apparaissent dans l'interface du proxy, et la commande adb shell settings get global http_proxy retourne l'adresse et le port de votre proxy. Si les deux conditions sont remplies, l'émulateur est correctement dirigé vers le proxy.

Problèmes possibles

  • Proxy status: Error dans le panneau de l'émulateur. Le proxy n'est pas lancé ou le port est différent. Lancez mitmweb ou Charles et cliquez sur Apply à nouveau.
  • Les requêtes n'apparaissent pas, bien que le statut soit Success. L'application utilise peut-être sa propre pile réseau ignorant le proxy système (par exemple les applications Flutter par défaut). Voir la section des erreurs typiques.
  • L'émulateur a perdu internet après la désactivation du proxy. Vous avez probablement laissé la valeur http_proxy vide au lieu de « :0 ». Reprenez la commande de désactivation avec le deux-points et le zéro, puis redémarrez l'émulateur.

Étape 3 : installer le certificat du proxy et résoudre le problème de confiance

Objectif de l'étape : l'émulateur et l'application de test font confiance au certificat racine du proxy, et vous voyez le contenu déchiffré des requêtes HTTPS : URL, en-têtes, corps des requêtes et des réponses.

Installer le certificat comme certificat utilisateur

  1. Assurez-vous que le proxy est activé sur l'émulateur (Étape 2).
  2. Dans Chrome à l'intérieur de l'émulateur, ouvrez l'adresse mitm.it (pour mitmproxy) ou chls.pro/ssl (pour Charles). Ce sont des adresses spéciales que le proxy intercepte et pour lesquelles il renvoie la page de téléchargement du certificat. Si au lieu d'une page vous voyez un site ordinaire ou une erreur — le trafic ne passe pas par le proxy, revenez à l'Étape 2.
  3. Pour mitmproxy, cliquez sur le bouton Android et téléchargez le fichier mitmproxy-ca-cert.cer. Pour Charles, le fichier se télécharge directement.
  4. Sur l'émulateur, ouvrez Réglages → Sécurité et confidentialité → Autres paramètres de sécurité → Chiffrement et identifiants → Installer un certificat → Certificat CA (sur certaines versions le chemin est : Sécurité → Paramètres supplémentaires → Chiffrement et identifiants). Un avertissement sur les risques apparaît — appuyez sur « Installer quand même ».
  5. Sélectionnez le fichier téléchargé dans le dossier Downloads. Si l'émulateur demande de définir un code PIN d'écran, mettez-en un simple, par exemple 1234, et retenez-le.
  6. Après l'installation, vérifiez : Chiffrement et identifiants → Certificats de confiance → onglet Utilisateur. Une entrée mitmproxy ou Charles Proxy CA doit y apparaître.

Méthode alternative sans navigateur — copier le fichier avec la commande adb push et le sélectionner ensuite depuis le gestionnaire de fichiers :

adb push ~/.mitmproxy/mitmproxy-ca-cert.cer /sdcard/Download/

À présent, Chrome dans l'émulateur ouvrira n'importe quel site HTTPS sans erreur, et dans le proxy vous verrez les requêtes déchiffrées du navigateur. Mais votre application de test, elle, plantera probablement toujours avec une erreur réseau. Passons au point principal.

Pourquoi l'application ne fait pas confiance et quoi demander aux développeurs

Comme nous l'avons vu dans les notions de base, les applications sous Android 7+ ignorent les certificats utilisateur. La bonne solution est que la build debug contienne un fichier de configuration de sécurité réseau. Le développeur ajoute dans res/xml/network_security_config.xml à peu près ce contenu :

<network-security-config><debug-overrides><trust-anchors><certificates src='system' /><certificates src='user' /></trust-anchors></debug-overrides></network-security-config>

Et le déclare dans AndroidManifest.xml via l'attribut android:networkSecurityConfig. Le bloc debug-overrides ne s'applique qu'aux builds de débogage, ce qui préserve la sécurité de la release. C'est une pratique standard, et dans la plupart des équipes ce fichier existe déjà. Copiez le fragment ci-dessus dans un ticket pour le développeur s'il n'existe pas.

Attention : ne demandez pas d'ajouter la confiance aux certificats utilisateur dans la configuration de base sans debug-overrides, et ne validez pas la désactivation de la vérification des certificats en release. Cela affaiblirait la protection des utilisateurs réels. Toutes les modifications doivent concerner uniquement les builds debug et QA.

Voie de secours : certificat système sur un émulateur rooté

Si la build ne peut pas être modifiée pour vous, sur un émulateur avec image Google APIs (pas Google Play), le certificat peut être placé dans le magasin système. Alors toutes les applications sans pinning lui feront confiance. En bref, pour Android 14 et plus récent, où les certificats système se trouvent dans la partition apex :

  1. Lancez l'émulateur depuis le terminal avec le flag -writable-system.
  2. Exécutez adb root, puis adb remount.
  3. Calculez le nom du fichier de certificat au format hash.0 avec la commande openssl x509 -inform PEM -subject_hash_old -in mitmproxy-ca-cert.cer -noout et renommez le fichier avec la valeur obtenue et le suffixe .0 (par exemple c8750f0d.0).
  4. Copiez le fichier dans le magasin de certificats système via adb push vers /system/etc/security/cacerts/ et redémarrez l'émulateur. Sur Android 14+, il faut en plus remonter le répertoire où le système charge les certificats ; la documentation de mitmproxy fournit un script prêt à l'emploi pour cela.

Cette voie est plus puissante mais plus fragile : après une mise à jour de l'image tout est réinitialisé, et sur Android 14+ les étapes sont plus complexes. Pour le travail quotidien, nous recommandons la première voie avec network_security_config.

Installer l'application de test

  1. Placez l'APK dans un dossier pratique.
  2. Exécutez adb install -r chemin/vers/app-debug.apk. Le flag -r réinstalle par-dessus la version existante en conservant les données.
  3. Après 10 à 30 secondes, Success apparaîtra et l'icône de l'application s'affichera dans l'émulateur.

Vérification : ouvrez l'application de test, connectez-vous à l'environnement de test. Des requêtes vers le domaine de l'environnement de test sont apparues dans mitmweb ou Charles, et si vous cliquez sur l'une d'elles, vous voyez les onglets avec les en-têtes, le corps de la requête en JSON et le corps de la réponse. Si le corps de la réponse est lisible — le certificat est installé et l'application lui fait confiance. C'est le point de contrôle principal de tout le guide.

Problèmes possibles

  • Chrome ouvre les sites, mais l'application affiche une erreur réseau. L'application ne fait pas confiance au certificat utilisateur. Il faut une build avec network_security_config ou un certificat système.
  • Dans les logs de l'application (adb logcat) on voit « Certificate pinning failure ». Le pinning est activé. Demandez une build QA avec pinning désactivé pour le domaine de l'environnement de test.
  • mitm.it affiche la page « If you can see this, traffic is not passing through mitmproxy ». Le proxy n'a pas été appliqué. Vérifiez le réglage de l'Étape 2.

Étape 4 : connecter un appareil réel en Wi-Fi

Objectif de l'étape : un vrai smartphone dans le même réseau Wi-Fi que l'ordinateur envoie son trafic vers le proxy.

C'est la méthode décrite dans les tutoriels grand public, mais le testeur a ses propres nuances : il doit savoir quand elle ne fonctionnera pas et pouvoir basculer rapidement. L'émulateur ne remplace pas un appareil réel : il n'a pas de vrai appareil photo, les notifications push arrivent différemment, les capteurs et la gestion d'énergie se comportent autrement. Tester les scénarios réseau sur un vrai téléphone est donc indispensable.

Configurer le proxy dans les paramètres Wi-Fi

  1. Connectez le téléphone au même réseau Wi-Fi que l'ordinateur. Un routeur domestique fera l'affaire. Un réseau d'entreprise invité — souvent non, voir ci-dessous.
  2. Ouvrez Réglages → Réseau et internet → Wi-Fi (sur Samsung : Connexions → Wi-Fi).
  3. Appuyez sur l'engrenage à côté du réseau actuel, ou faites un appui long sur le nom du réseau pour ouvrir le menu et choisir « Modifier le réseau ».
  4. Dépliez « Avancé » ou « Paramètres avancés ».
  5. Dans le champ Proxy, choisissez Manuel.
  6. Nom d'hôte du proxy : l'adresse IP de votre ordinateur, par exemple 192.168.1.45. Port : 8080 ou 8888. Laissez vide le champ « Ne pas utiliser de proxy pour ».
  7. Enregistrez. Le téléphone se reconnectera au réseau.

Installer le certificat sur le téléphone

  1. Ouvrez Chrome sur le téléphone et allez sur mitm.it ou chls.pro/ssl. Téléchargez le certificat.
  2. Réglages → Sécurité → Chiffrement et identifiants → Installer un certificat → Certificat CA → sélectionnez le fichier. Les noms de menus diffèrent légèrement chez Samsung, Xiaomi, Huawei, mais la logique reste la même : cherchez les mots « identifiants » ou « certificat ».
  3. Installez l'application de test via adb install ou directement depuis le fichier.

Astuce : attribuez à l'ordinateur une adresse IP fixe dans les réglages du routeur (réservation DHCP par adresse MAC). Sinon, après un redémarrage du routeur l'adresse changera, et tous les téléphones de l'équipe cesseront de passer par le proxy, tandis que vous chercherez la cause pendant une demi-heure.

Quand la méthode Wi-Fi ne fonctionne pas

  • Isolation des clients (AP isolation) sur un réseau d'entreprise ou invité. Les appareils voient internet mais pas les uns les autres. Symptôme : le téléphone avec le proxy perd complètement internet, et mitm.it ne s'ouvre pas. Vérification : depuis l'ordinateur, exécutez ping sur l'adresse IP du téléphone (visible dans les propriétés Wi-Fi). Pas de réponse — il y a isolation.
  • Ordinateur et téléphone sur des sous-réseaux différents. Par exemple le portable est en filaire sur 10.10.0.x et le téléphone en Wi-Fi sur 192.168.1.x.
  • Le pare-feu de l'ordinateur bloque les entrées. Problème fréquent sous Windows avec un réseau « Public ». Basculez le profil de réseau sur « Privé ».

Dans tous ces cas, la solution est la même — un tunnel de port par USB, que nous abordons maintenant.

Vérification : des requêtes venant du téléphone sont apparues dans l'interface du proxy, et dans Charles la colonne Client affiche l'IP du téléphone, différente de 127.0.0.1. Ouvrez l'application de test, effectuez une action — la requête correspondante vers l'environnement de test est apparue dans la liste avec un corps déchiffré.

Étape 5 : tunnel de port via adb reverse — proxy par USB sans Wi-Fi

Objectif de l'étape : un vrai téléphone connecté uniquement par câble USB redirige son trafic vers le proxy de l'ordinateur, indépendamment du réseau Wi-Fi.

C'est la méthode la plus fiable pour le bureau, un espace de coworking et tout réseau où vous ne gérez pas le routeur. L'idée : avec la commande adb reverse, on fait en sorte que le port 8080 du téléphone pointe vers le port 8080 de l'ordinateur. Ensuite, on dit au téléphone d'utiliser le proxy 127.0.0.1:8080 — c'est-à-dire « lui-même », et adb achemine discrètement les paquets vers l'ordinateur.

Activer le débogage USB

  1. Sur le téléphone, ouvrez Réglages → À propos du téléphone et appuyez sept fois sur « Numéro de build ». Un message « Vous êtes maintenant développeur » apparaîtra. Sur Xiaomi, il faut appuyer sur « Version MIUI » ou « Version HyperOS ».
  2. Revenez dans Réglages → Système → Options pour les développeurs (sur Samsung — à la racine des Réglages). Activez l'interrupteur Débogage USB.
  3. Branchez le téléphone à l'ordinateur avec le câble. Sur le téléphone, une demande « Autoriser le débogage USB ? » apparaîtra avec l'empreinte de l'ordinateur. Cochez « Toujours autoriser » et appuyez sur Autoriser.
  4. Sur l'ordinateur, exécutez adb devices. Une ligne avec le numéro de série et le mot device doit apparaître. Si unauthorized est affiché — regardez l'écran du téléphone, la demande y est en attente. Si offline — rebranchez le câble.

Attention : utilisez un câble qui prend en charge le transfert de données. Beaucoup de câbles bon marché fournis avec des batteries externes ne font que charger. Si le téléphone charge mais adb devices reste vide — changez d'abord le câble, pas les pilotes.

Effectuer le tunnel

  1. Assurez-vous que le proxy de l'ordinateur est lancé et écoute sur le port 8080.
  2. Exécutez la commande :
    adb reverse tcp:8080 tcp:8080
    Le premier nombre est le port sur le téléphone, le second est le port sur l'ordinateur. En réponse, la commande affiche 8080 ou rien — c'est normal.
  3. Vérifiez la liste des tunnels actifs :
    adb reverse --list
    Une ligne du type host-numéro tcp:8080 tcp:8080 doit apparaître.
  4. Si plusieurs appareils sont connectés (par exemple un émulateur et un téléphone), indiquez le numéro de série avec le flag -s :
    adb -s R58M1234ABC reverse tcp:8080 tcp:8080

Indiquer au téléphone un proxy sur localhost

Deux chemins possibles ici. Le premier — via adb, le plus rapide :

adb shell settings put global http_proxy 127.0.0.1:8080

Le second — manuellement dans les réglages Wi-Fi du téléphone, comme à l'Étape 4, mais en indiquant 127.0.0.1 dans le champ hôte et 8080 en port. Le second est nécessaire sur certains firmwares où le réglage global via adb ne s'applique pas à toutes les applications.

Notez une nuance importante. Le réglage global http_proxy est appliqué par le système à la connexion réseau en cours. Si le Wi-Fi est désactivé et que le téléphone utilise les données mobiles, certains firmwares l'appliquent quand même, d'autres non. Le plus fiable est de garder le Wi-Fi activé (n'importe quel réseau, même sans accès à l'ordinateur) et d'y indiquer le proxy 127.0.0.1. Le trafic passera par adb reverse en USB, indépendamment du réseau Wi-Fi auquel le téléphone est connecté.

Installer le certificat

La procédure est la même qu'avant : Chrome → mitm.it → télécharger → installer comme certificat CA. Si le certificat est déjà installé sur ce téléphone depuis l'Étape 4, inutile de recommencer.

Désactiver le tunnel après le travail

  1. Retirez le proxy : adb shell settings put global http_proxy :0 (ou « Aucun » dans les réglages Wi-Fi).
  2. Supprimez le tunnel : adb reverse --remove tcp:8080 ou tout d'un coup : adb reverse --remove-all.
  3. Notez que lorsque vous débranchez le câble, les tunnels se réinitialisent automatiquement, mais le réglage du proxy sur le téléphone, lui, reste. Si vous oubliez de le retirer, le téléphone sans câble n'aura plus internet. C'est exactement la plainte la plus fréquente des débutants : « le téléphone ne charge plus rien ».

Astuce : écrivez-vous une antisèche de trois lignes : adb reverse tcp:8080 tcp:8080, adb shell settings put global http_proxy 127.0.0.1:8080, adb shell settings put global http_proxy :0. Ces trois commandes suffisent pour 90 % des situations de travail avec un appareil réel.

Vérification : désactivez le Wi-Fi de l'ordinateur ou utilisez le téléphone sur un réseau d'où l'ordinateur n'est pas accessible. Exécutez adb reverse, réglez le proxy 127.0.0.1:8080, ouvrez mitm.it dans Chrome sur le téléphone. La page de téléchargement du certificat s'ouvre — le tunnel fonctionne. Ensuite, ouvrez l'application de test et vérifiez que ses requêtes apparaissent dans le proxy.

Problèmes possibles

  • adb reverse renvoie « error: closed » ou « more than one device ». Plusieurs appareils sont connectés ; indiquez -s numéro_de_série. Ou l'appareil est passé en offline — rebranchez le câble.
  • Le tunnel existe, mais mitm.it ne s'ouvre pas. Vérifiez que le proxy de l'ordinateur écoute bien sur 127.0.0.1 ou sur toutes les interfaces, pas seulement sur l'IP externe. mitmproxy écoute par défaut sur toutes les interfaces. Charles aussi.
  • Après avoir rebranché le câble, le trafic a disparu. adb reverse se réinitialise à chaque rebranchement. Exécutez la commande à nouveau. Le réglage du proxy sur le téléphone, lui, est conservé.

Étape 6 : intercepter et modifier le trafic de l'environnement de test

Objectif de l'étape : savoir filtrer les requêtes vers l'environnement de test, lire les corps de requêtes et de réponses, mettre une requête en pause et modifier la réponse du serveur, simuler des erreurs et un réseau lent, et aussi rediriger l'application vers un back-end local via adb reverse.

Filtrer uniquement ce qui compte

L'application envoie des dizaines de requêtes en arrière-plan : analytique, mise à jour de configuration, vérification de version. Pour ne pas se noyer, configurez un filtre par domaine de l'environnement de test.

  1. Dans mitmweb, saisissez dans le champ de filtre en haut une expression comme ~d api-stage.example-team.ru — seules les requêtes vers ce domaine resteront. L'expression ~u /orders filtre par partie d'URL, ~c 500 n'affiche que les réponses au code 500, et ~m POST seulement les requêtes POST. Les expressions se combinent par un espace.
  2. Dans Charles, activez le mode Focus : clic droit sur l'hôte de l'environnement de test → Focus. Les autres hôtes se replieront dans le groupe Other Hosts. En complément, on peut saisir une partie d'URL dans le champ Filter en bas.

Lire la requête et la réponse pour pouvoir les joindre au bug

  1. Cliquez sur une ligne de requête. Dans mitmweb, les onglets Request, Response, Detail apparaissent à droite. Dans Charles — les onglets Overview, Contents, Summary et en bas les commutateurs Headers, JSON Text, Raw.
  2. Copiez l'URL, la méthode, le code de réponse et le corps de la réponse en JSON. Dans mitmweb, on peut faire un clic droit sur la requête et choisir Export → curl : on obtient une commande que le développeur reproduira chez lui en une seconde. Dans Charles de même : clic droit → Copy cURL Request.
  3. Un bon rapport de bug sur une erreur réseau contient toujours : les étapes, l'URL avec la méthode, le code et le corps de la réponse, l'heure de la requête (pour la retrouver dans les logs serveur) et l'identifiant de requête des en-têtes si le back-end en renvoie (souvent X-Request-Id).

Mettre une requête en pause et changer la réponse

Scénario classique : il faut vérifier comment l'application affichera un panier avec cent articles ou un prix négatif, alors que l'environnement de test n'a pas ces données. On substitue la réponse.

  1. Dans mitmweb, saisissez dans le champ Intercept un filtre, par exemple ~u /cart. Toutes les requêtes avec cette URL seront désormais arrêtées. Effectuez l'action dans l'application. La requête apparaîtra marquée intercepted. Cliquez dessus, appuyez sur Resume après avoir édité la réponse dans l'onglet Response (icône crayon). L'application recevra les données modifiées.
  2. Dans Charles, activez les Breakpoints : clic droit sur la requête → Breakpoints. À la prochaine requête de ce type, une fenêtre s'ouvrira en deux phases : d'abord Edit Request, puis Edit Response. Modifiez le JSON dans l'onglet Response et cliquez sur Execute.
  3. Gardez à l'esprit que les applications ont un timeout, généralement 10 à 30 secondes. Si vous mettez plus longtemps à éditer la réponse, l'application affichera une erreur réseau au lieu de vos données. Préparez le JSON à l'avance dans un éditeur de texte et collez-le en entier.

Substitution permanente de la réponse : Map Local

Si le scénario se répète, les pauses manuelles sont fastidieuses. Charles propose Tools → Map Local : vous indiquez une URL et un fichier JSON local, et chaque requête correspondante recevra le contenu du fichier au lieu de la réponse de l'environnement de test. Dans mitmproxy l'équivalent est l'option map_local avec un motif d'URL et un chemin de fichier, ainsi que de petits scripts Python avec une fonction response qui peut modifier n'importe quel champ. Par exemple, un script de cinq lignes peut remplacer dans toutes les réponses de l'environnement de test la valeur du champ balance par le nombre souhaité.

Simuler des erreurs serveur

Comment l'application se comporte-t-elle face à un 500, un 401 ou une réponse vide ? Difficile à tester sur l'environnement de test, mais facile via le proxy. Dans Charles : Tools → Rewrite → ajoutez une règle pour l'URL de l'environnement de test avec le type Response Status et la valeur 500. Dans mitmproxy : en mode interception, changez le code de statut dans l'éditeur de réponse, ou utilisez un script avec flow.response.status_code = 500. Vérifiez que l'application affiche une erreur compréhensible, et non un crash ou un loader infini.

Simuler un réseau lent

Dans Charles, activez Proxy → Throttle Settings, choisissez un preset 3G ou définissez vos propres valeurs : bande passante, latence, pourcentage de pertes. N'oubliez pas de limiter le Throttle à l'hôte de l'environnement de test, sinon les autres connexions seront aussi ralenties. Testez le chargement des listes, l'annulation des requêtes en quittant un écran et le comportement en cas de timeout. L'émulateur Android sait aussi limiter le réseau : Extended Controls → Cellular → Network type, mais le proxy offre un contrôle plus fin.

Rediriger l'application vers un back-end local

Tâche fréquente : un développeur a lancé un serveur sur son portable sur le port 3000 et demande de vérifier une fonctionnalité avant la mise en staging. L'application sur un vrai téléphone ne voit pas son localhost. La solution — encore adb reverse :

adb reverse tcp:3000 tcp:3000

Maintenant, dans l'application (via un menu caché de sélection d'environnement ou le réglage du base URL dans la build QA), indiquez l'adresse http://localhost:3000, et les requêtes partiront vers l'ordinateur. Si l'interception est aussi nécessaire, laissez le proxy activé : mitmproxy verra les requêtes vers localhost:3000 comme des requêtes ordinaires. Sur l'émulateur, au lieu d'adb reverse, on peut simplement utiliser l'adresse http://10.0.2.2:3000.

Astuce : sauvegardez vos sessions. Dans Charles — File → Save Session, dans mitmproxy — la commande mitmdump -w session.mitm ou le bouton de sauvegarde dans mitmweb. Un fichier de session permettant de rejouer un bug vaut plus que n'importe quelle description : le développeur l'ouvrira et verra toutes les requêtes dans le même ordre que vous.

Vérification : vous savez : n'afficher que les requêtes vers l'environnement de test ; copier n'importe quelle requête en curl ; arrêter une requête et renvoyer à l'application un JSON modifié qui s'affichera à l'écran ; faire recevoir à l'application un code 500 et voir sa réaction ; ralentir le réseau et voir l'indicateur de chargement. Si ces cinq points sont acquis, vous maîtrisez le proxy au niveau d'un utilisateur confirmé.

Vérification du résultat : checklist finale

Parcourez la liste et cochez chaque point. Tous doivent être validés — alors l'environnement est totalement prêt pour le travail quotidien.

Proxy sur l'ordinateur

  • mitmweb ou Charles se lance sans erreur et écoute son port.
  • La commande curl -x http://127.0.0.1:8080 -k https://example.com affiche la requête dans l'interface.
  • Le fichier du certificat racine est trouvé et vous savez où il se trouve.

Émulateur

  • adb devices affiche l'émulateur avec le statut device.
  • adb shell settings get global http_proxy retourne 10.0.2.2:8080, ou le panneau Extended Controls affiche le statut Success.
  • Chrome dans l'émulateur ouvre les sites HTTPS sans avertissement.
  • Le certificat est visible dans l'onglet Utilisateur des réglages de sécurité.
  • L'application de test fonctionne, ses requêtes vers l'environnement de test sont visibles avec les corps déchiffrés.

Appareil réel

  • Le débogage USB est activé, adb devices voit le téléphone.
  • En Wi-Fi : proxy sur l'IP de l'ordinateur, mitm.it s'ouvre, les requêtes de l'application sont visibles.
  • En USB : adb reverse --list affiche tcp:8080, le proxy 127.0.0.1:8080 est réglé, mitm.it s'ouvre avec le Wi-Fi de l'ordinateur désactivé.
  • Vous savez désactiver le proxy et le tunnel, et après désactivation le téléphone retrouve normalement internet.

Travail avec l'environnement de test

  • Un filtre par domaine de l'environnement de test est configuré.
  • Au moins une substitution de réponse a été réalisée via une pause ou Map Local.
  • La réaction de l'application au code 500 a été testée.
  • Une session avec un exemple de trafic a été sauvegardée.

Scénario de test pour l'auto-vérification

  1. Lancez le proxy, l'émulateur et activez le proxy sur l'émulateur.
  2. Ouvrez l'application, connectez-vous, ouvrez n'importe quelle liste de données.
  3. Trouvez dans le proxy la requête qui a renvoyé cette liste. Mettez une interception sur son URL.
  4. Rafraîchissez la liste dans l'application, dans la réponse stoppée supprimez la moitié des éléments, relâchez.
  5. L'écran de l'application doit afficher moins d'éléments. Si oui — l'environnement est totalement opérationnel.

Erreurs typiques et solutions

Problème 1 : l'application affiche une erreur réseau, mais le navigateur fonctionne

Cause : l'application ne fait pas confiance au certificat utilisateur (comportement par défaut d'Android 7+) ou le certificate pinning est activé. Solution : demandez une build debug avec network_security_config et le bloc debug-overrides, ou une build QA avec pinning désactivé pour l'environnement de test. En dépannage sur un émulateur Google APIs — un certificat système. Pour identifier la cause, adb logcat avec filtre sur le mot Trust ou pinning aide.

Problème 2 : aucune requête n'apparaît, bien que le proxy soit réglé

Cause : l'application utilise une bibliothèque réseau qui ignore le proxy système. C'est le cas des applications Flutter (client dart:io), de certaines builds React Native et des applications gRPC. Solution : pour Flutter, le développeur ajoute dans la build debug le support du proxy système via un paquet lisant les réglages de proxy, ou définit explicitement findProxy vers 10.0.2.2:8080 en mode débogage. C'est une demande standard, les développeurs Flutter la connaissent. Alternative — le mode proxy transparent, mais il est plus complexe et n'est pas traité ici.

Problème 3 : le téléphone n'a plus internet après les tests

Cause : le proxy est resté dans les réglages Wi-Fi ou dans le réglage global http_proxy, tandis que le serveur proxy est éteint ou le câble débranché. Solution : adb shell settings put global http_proxy :0, et dans les réglages Wi-Fi mettre le proxy sur « Aucun ». Ajoutez cette action à la fin de votre rituel de travail.

Problème 4 : adb ne voit pas l'appareil

Cause : câble de charge uniquement, demande de débogage non confirmée, pilote non installé sous Windows, appareil en mode « Charge uniquement » au lieu de « Transfert de fichiers ». Solution : changez le câble, vérifiez l'écran du téléphone, basculez le mode USB dans le volet de notifications sur « Transfert de fichiers », sous Windows installez Google USB Driver via le SDK Manager ou le pilote du fabricant. adb kill-server puis adb start-server aide aussi.

Problème 5 : Charles n'affiche que CONNECT sans contenu

Cause : SSL Proxying n'est pas activé ou le domaine n'est pas dans Include. Solution : Proxy → SSL Proxying Settings → Enable → Add hôte * port 443. Après activation, rouvrez l'application : les connexions déjà établies ne seront pas déchiffrées rétroactivement.

Problème 6 : dans le panneau de l'émulateur, Proxy status: Error

Cause : le proxy de l'ordinateur n'est pas lancé ou le port est différent. Parfois — Android Studio intercepte les réglages avec son propre proxy. Solution : lancez le proxy, décochez l'utilisation des réglages d'Android Studio, cliquez à nouveau sur Apply. Si ça ne suffit pas — réglez le proxy via adb avec l'adresse 10.0.2.2.

Problème 7 : mitm.it ne s'ouvre pas, mais le reste d'internet fonctionne

Cause : le trafic passe à côté du proxy. Sur un appareil réel en Wi-Fi, c'est souvent l'isolation des clients du réseau. Solution : vérifiez avec un ping vers le téléphone depuis l'ordinateur. Pas de réponse — passez à adb reverse. Réponse — vérifiez le pare-feu et le port.

Problème 8 : après une mise à jour d'Android Studio, le certificat a disparu

Cause : vous avez fait un Wipe Data de l'émulateur ou l'avez recréé. Solution : le certificat utilisateur s'installe en une minute via mitm.it. Pour ne pas perdre l'état, utilisez les snapshots de l'émulateur (Snapshots dans Extended Controls) : enregistrez un snapshot après l'installation du certificat et de l'application.

Problème 9 : plusieurs appareils et des commandes appliquées au mauvais

Cause : adb sans le flag -s, avec deux appareils connectés ou plus, refuse de fonctionner ou agit sur un appareil inattendu. Solution : utilisez toujours adb -s numéro_de_série, et consultez les numéros via adb devices. On peut aussi définir la variable d'environnement ANDROID_SERIAL avec le bon numéro.

Fonctionnalités avancées pour testeurs confirmés

Simulateur iOS et iPhone réel

La logique est la même, les outils diffèrent. Le simulateur iOS utilise les réglages réseau de macOS, donc le proxy se règle dans les préférences Système Réseau du Mac, et le certificat se glisse dans la fenêtre du simulateur puis s'active dans Réglages → Général → Informations sur l'appareil → Confiance dans les certificats. Sur un iPhone réel, le proxy se règle dans les propriétés Wi-Fi, le certificat se télécharge via mitm.it et s'active par le même chemin avec la confiance. Il n'y a pas d'équivalent à adb reverse pour l'iPhone par USB ; dans les réseaux fermés on utilise le partage de connexion depuis un Mac par câble.

Automatisation avec mitmdump et des scripts

mitmdump fonctionne sans interface et accepte des scripts Python. Exemple de tâche : remplacer dans toutes les réponses de l'environnement de test le champ feature_flags pour activer une fonctionnalité expérimentale sans accès à l'admin. Le script se lance avec le flag -s script.py, et le trafic s'écrit dans un fichier avec le flag -w. Ces scripts gagnent à être stockés dans le dépôt de tests à côté des tests automatisés.

Intégration avec Appium et les tests automatisés

Dans les tests automatisés, le proxy s'active avant le lancement de la session : configuration via adb, puis vérification non seulement de l'UI mais aussi du trafic. Par exemple, un test clique sur « Payer » et vérifie qu'un POST vers /payments avec le bon montant est apparu dans mitmproxy. Cela attrape des bugs que l'UI ne montre pas : duplication de requêtes, envoi de champs superflus, mauvais format de dates.

Vérifier l'analytique et le tracking

Le proxy est irremplaçable pour tester les événements d'analytique : vous voyez quels événements et avec quels paramètres l'application envoie à chaque action. Un filtre par domaine du système d'analytique et la colonne du corps de requête remplacent de longues attentes d'apparition des événements dans les dashboards.

Plusieurs émulateurs avec des proxies différents

Si vous devez comparer le comportement face à différentes réponses de l'environnement de test, lancez deux proxies sur les ports 8080 et 8090 et deux émulateurs, chacun avec son proxy via adb -s. C'est pratique pour vérifier les variantes A/B : un émulateur reçoit la réponse modifiée via Map Local, l'autre l'originale.

Snapshots d'émulateur comme environnement propre

Après avoir configuré le proxy, le certificat et l'application, enregistrez un snapshot de l'émulateur. Avant chaque campagne de test, chargez-le — vous obtenez un environnement identique en quelques secondes, sans réinstallation.

Séparer les environnements et la sécurité

Gardez des profils Charles distincts ou des configurations mitmproxy pour chaque projet. N'activez pas l'interception de tout le trafic de l'ordinateur au niveau système — uniquement celui des appareils. Et vérifiez régulièrement que les appareils de test n'ont pas de comptes personnels, car tout leur trafic est visible dans le proxy.

FAQ : questions fréquentes sur la configuration du proxy en test mobile

Quelle différence entre adb reverse et adb forward ?

adb reverse fait pointer un port de l'appareil vers l'ordinateur : l'application sur le téléphone contacte localhost et atteint le PC. adb forward — l'inverse : un port de l'ordinateur pointe vers l'appareil, c'est ainsi qu'on se connecte par exemple à un débogueur ou à un serveur web à l'intérieur du téléphone. Pour un proxy et un back-end local, c'est bien reverse qu'il faut.

Faut-il vraiment installer le certificat si seules les URL des requêtes m'intéressent ?

Non. Sans certificat, vous verrez les hôtes et les requêtes CONNECT, mais pas les chemins, paramètres et corps. Cependant l'application recevra alors des erreurs TLS, il sera donc impossible de la tester correctement. En pratique, on installe toujours le certificat.

Pourquoi sur l'émulateur l'adresse de l'ordinateur est 10.0.2.2, alors que dans le panneau Extended Controls il faut écrire 127.0.0.1 ?

Le panneau de l'émulateur applique le proxy du côté de la machine hôte, donc l'adresse de l'ordinateur y est 127.0.0.1. La commande adb shell, elle, s'exécute à l'intérieur d'Android, où 127.0.0.1 est l'émulateur lui-même et l'ordinateur est accessible via 10.0.2.2. Retenez la règle : à l'intérieur d'Android — 10.0.2.2, à l'extérieur — 127.0.0.1.

Peut-on utiliser un proxy sur un appareil sans root ?

Oui. Tout ce qui est décrit dans le guide, sauf l'installation du certificat système, fonctionne sans root. La condition clé — une build debug de l'application qui fait confiance aux certificats utilisateur.

Que faire si l'application cesse de fonctionner via le proxy après une mise à jour de la build ?

Les développeurs ont probablement activé le pinning ou retiré les debug-overrides. Vérifiez adb logcat pour les erreurs de certificats et demandez à l'équipe ce qui a changé dans la configuration réseau. Cela arrive souvent lors du passage à une nouvelle bibliothèque de client HTTP.

Comment tester l'application via proxy en utilisant les données mobiles plutôt que le Wi-Fi ?

Utilisez adb reverse par USB et le réglage global http_proxy 127.0.0.1:8080. Sur la plupart des appareils, le proxy s'appliquera aussi aux données mobiles. Sinon — testez en Wi-Fi, et vérifiez les scénarios de bascule réseau séparément sans proxy.

Peut-on intercepter le trafic d'une version production du store ?

Techniquement, les builds de release ne font pas confiance aux certificats utilisateur et contiennent souvent du pinning, donc sans modifications cela ne fonctionne pas. Et c'est tant mieux : la protection des utilisateurs prime sur le confort du testeur. Faites toutes les vérifications sur des builds de test et sur l'environnement de test.

Comment savoir si une requête vient de l'application, d'un service en arrière-plan ou du navigateur ?

Dans Charles il y a une colonne Client Process sur macOS, mais sur l'appareil l'information de processus n'est pas transmise. Astuce pratique : fermez toutes les autres applications, filtrez par domaine de l'environnement de test et reproduisez l'action de façon ciblée. En cas de doute, regardez l'en-tête User-Agent — les applications y mettent généralement leur nom et leur version.

Comment sauvegarder le trafic et le transmettre au développeur ?

Dans Charles — File → Save Session As au format .chls ou Export au format HAR. Dans mitmproxy — le flag -w pour l'enregistrement ou la sauvegarde depuis l'interface web. Le format HAR est lisible par presque tous les outils, y compris l'onglet Network des outils de développement du navigateur.

Combien de temps prend la configuration quotidienne après la première fois ?

Lancer le proxy, l'émulateur depuis un snapshot et activer le proxy via adb — environ une minute. Appareil réel en USB — deux commandes et dix secondes. La configuration du certificat ne se répète qu'après une réinitialisation de l'appareil.

Conclusion

Résumons. Vous avez monté un proxy d'interception sur l'ordinateur et vérifié qu'il voit le trafic. Vous y avez dirigé l'émulateur Android de trois manières différentes et démêlé les adresses 127.0.0.1 et 10.0.2.2. Vous avez installé le certificat racine et compris pourquoi l'application peut ne pas lui faire confiance et quoi demander précisément aux développeurs. Vous avez connecté un appareil réel en Wi-Fi, rencontré les limites des réseaux d'entreprise et résolu le problème par un tunnel de port via adb reverse. Vous avez appris à filtrer le trafic de l'environnement de test, à mettre des requêtes en pause, à substituer les réponses, à simuler des erreurs serveur et un réseau lent, et à rediriger l'application vers le back-end local d'un collègue.

C'est l'ensemble de compétences qui distingue un testeur d'applications mobiles capable de trouver et localiser les bugs réseau par lui-même. Vos rapports de bug deviendront plus précis, et les développeurs vous sauront gré des commandes curl prêtes à l'emploi et des fichiers de session.

Que faire ensuite

  • Refaites la configuration sur votre projet professionnel, obtenez l'apparition des requêtes déchiffrées vers l'environnement de test.
  • Rédigez votre antisèche personnelle des commandes adb et enregistrez un snapshot de l'émulateur avec l'environnement prêt.
  • Menez un cycle de test complet d'une fonctionnalité avec le proxy ouvert et comptez combien de bugs ont été trouvés grâce à la visibilité du trafic.

Comment progresser

Le niveau suivant — des scripts mitmproxy en Python qui substituent automatiquement les réponses, l'intégration de vérifications du trafic dans des tests automatisés Appium et le test de l'API de l'environnement de test directement via Postman ou curl en parallèle du client mobile. Il est utile d'apprendre les bases de TLS et la structure des certificats pour parler avec assurance aux développeurs de pinning et de configuration de sécurité réseau. Et apprenez absolument la partie iOS : les compétences qui testent les deux clients sont précieuses chez les spécialistes à l'aise sur les deux plateformes. Vous allez y arriver — vous avez déjà fait le plus dur.