Sorgin Informatique

Comment tester la sécurité d'une application mobile avant publication

Un `Log.d()` oublié a suffi à exposer les jetons de session des utilisateurs de mon app. Voici la séquence exacte de tests sécurité — analyse statique, dynamique, API, stockage — que j'applique désormais avant chaque publication.

Comment tester la sécurité d'une application mobile avant publication

Une application plantée en démo client, ça arrive. Mais une application qui fuit les jetons de session de vos utilisateurs dans un fichier de log lisible par n'importe quel autre programme installé sur le téléphone, ça ne se voit pas en démo. Ça se voit dans les rapports de fuite de données, six mois plus tard, quand il est trop tard pour faire machine arrière.

J'ai appris ça de la mauvaise manière sur un projet perso : une petite app de suivi de dépenses, publiée un peu vite parce que « ça marchait sur mon téléphone ». Trois semaines après la mise en ligne, un utilisateur m'a envoyé une capture d'écran. Le jeton d'authentification s'affichait en clair dans le journal de crash d'Android. Pas de faille spectaculaire, juste un Log.d() oublié dans une méthode de debug. C'est bête. C'est aussi la façon la plus courante de laisser entrer quelqu'un.

Alors voici comment je teste maintenant la sécurité d'une application mobile avant publication — la séquence exacte, les outils, et les endroits où je me suis planté.

Points clés à retenir

  • Une app mobile n'est pas un site web : le binaire est entre les mains de l'utilisateur, donc lisible, décompilable, modifiable.
  • La séquence qui fonctionne : analyse statique du paquet → analyse dynamique → test d'API → contrôle du stockage local → vérification des déclarations de confidentialité.
  • Les SDK tiers sont le trou dans la raquette le plus fréquent : ils collectent souvent plus que ce que vous croyez.
  • Les déclarations de confidentialité des stores sont auto-renseignées par l'éditeur. Personne ne les vérifie à votre place.
  • Tester sur un appareil réel avec les options de développeur, pas seulement sur l'émulateur.

Pourquoi tester la sécurité d'une application mobile avant publication change tout

Sur le web, vous corrigez un bug en déployant une nouvelle version. Sur mobile, chaque version installée vit sa vie sur des appareils que vous ne contrôlez pas. Vous ne pouvez pas reprendre un jeton volé, vous ne pouvez pas effacer un fichier de cache distant, vous ne pouvez pas forcer une mise à jour immédiate sur l'ensemble du parc — les stores laissent toujours un délai, et une partie des utilisateurs ne met jamais à jour.

D'où une règle que je me suis fixée : tout ce qui quitte l'application est compromis par défaut. Ce n'est pas de la paranoïa, c'est de la mécanique. Un téléphone rooté, un appareil de test avec un proxy qui intercepte le trafic, un fichier de sauvegarde extrait : tout cela est à la portée de quelqu'un de motivé.

Ce qui distingue vraiment le test d'une app de celui d'un site

Trois choses, concrètement :

  • Le code est embarqué. Un APK se décompresse avec un outil gratuit en quelques minutes. Les chaînes de caractères, les URL, parfois des clés d'API y sont en clair.
  • Le stockage local est exposé. Un fichier posé dans le répertoire privé de l'app reste lisible si l'appareil est rooté ou si une sauvegarde non chiffrée est activée.
  • Le trafic est interceptable. Sans épinglage de certificat (certificate pinning), n'importe quel proxy installé sur le téléphone lit vos requêtes en clair.

Le reste — authentification, gestion de session, droits d'accès — ressemble à du web, mais avec une différence de taille : côté mobile, le client est hostile par nature. Vous ne pouvez pas faire confiance à l'app pour valider quoi que ce soit. Chaque contrôle d'accès doit exister côté serveur.

Comment vérifier si une application est fiable ?

La question m'est posée souvent, et la réponse honnête est : pas entièrement, pas depuis l'extérieur. Mais on peut faire beaucoup mieux que « elle a de bonnes notes sur le store ». Voici ce que je regarde, dans cet ordre.

Les signaux vérifiables avant d'installer

Commencez par la fiche du store. L'éditeur y déclare les données collectées — c'est une déclaration, pas une preuve, mais une incohérence flagrante (une app de lampe de poche qui déclare accéder aux contacts) est un signal fort. Regardez ensuite qui édite : une société identifiable avec un site, une adresse, c'est déjà mieux qu'un nom d'éditeur générique.

Le contenu de l'APK ou de l'IPA est consultable. Un fichier de paquet se décompresse, et un fichier de configuration réseau y trahit souvent plus que l'éditeur ne le souhaiterait. Ce n'est pas à la portée de tout le monde, mais c'est ce que fait un auditeur — je le fais pour mes propres apps, jamais pour celles des autres sans leur accord.

Ce qui ne prouve rien, malgré les apparences

  • Le nombre de téléchargements : une app très installée peut être mal codée.
  • Le cadenas dans la barre d'adresse de la version web : il ne dit rien du traitement côté serveur.
  • Une note moyenne élevée : elle mesure la satisfaction, pas la robustesse.
  • « Elle demande peu de permissions » : c'est un bon point, mais certaines permissions sensibles se contournent via des SDK intégrés.

Mon critère personnel, celui sur lequel je ne cède pas : une app qui demande l'accès à vos contacts ou à vos SMS sans que la fonctionnalité l'exige explicitement est une app que je n'installe pas.

Quels sont les 3 types de tests d'intrusion les plus courants ?

Trois familles, et elles ne testent pas la même chose. Confondre les trois, c'est payer pour un audit qui ne couvre pas le risque réel de votre application.

1. Le test en boîte noire

L'auditeur n'a aucune information sur l'application : ni le code source, ni l'architecture, ni les identifiants. Il attaque comme le ferait un utilisateur curieux ou un attaquant qui a trouvé l'app sur le store. C'est le scénario le plus réaliste, et souvent le plus révélateur sur les erreurs basiques : endpoints non protégés, absence de limitation de tentatives de connexion, jetons qui traînent.

2. Le test en boîte blanche

Là, l'auditeur a le code, les schémas, les accès à l'environnement de recette. Il peut suivre le flux de données de bout en bout et repérer des failles logiques invisibles de l'extérieur : une règle métier qu'on peut contourner en modifiant une valeur, une vérification d'autorisation qui n'existe que côté client. C'est le plus coûteux en temps, et le seul qui couvre vraiment les failles d'autorisation.

3. Le test en boîte grise

Un compromis : l'auditeur part avec un compte utilisateur standard et quelques informations d'architecture. Il teste surtout l'élévation de privilèges — est-ce qu'un utilisateur normal peut atteindre les données d'un autre ? C'est le format que je recommande en priorité pour une app grand public, parce qu'il cible exactement ce qu'un attaquant chercherait à faire.

Type Ce qu'il trouve bien Sa limite
Boîte noire Failles d'exposition, mauvaise configuration, absence de protections basiques Ne voit pas la logique interne
Boîte blanche Failles logiques, chemins d'autorisation, défauts de conception Demande du temps, donc un budget
Boîte grise Élévation de privilèges, fuite entre comptes Ne couvre pas tout le périmètre d'une boîte blanche

Et un point que personne ne dit assez : un pentest n'est pas un audit de conformité. Il produit un rapport daté, avec des constats à un instant T. Ce n'est pas un certificat de sécurité pour toujours.

Comment tester une application Android sur votre téléphone ?

Sur Android, c'est plus accessible que sur iOS, et c'est une bonne raison de commencer par là. Voici ma séquence, avec les options de développeur.

Comment tester une application Android sur votre téléphone ?

Préparer l'appareil

  1. Installez la version de test, pas la version de production — l'APK de debug, si l'éditeur en fournit un.
  2. Activez les options de développeur (généralement un appui répété sur le numéro de build).
  3. Activez le débogage USB, puis branchez l'appareil sur un poste et lancez une capture de trafic via un outil comme ADB et un inspecteur réseau.
  4. Posez un proxy sur le téléphone et observez les requêtes. Si tout passe en clair, c'est déjà une réponse.

Ce qu'on observe ensuite

Trois choses à vérifier dans les premières minutes : le trafic sortant (vers quels domaines, en clair ou non), le stockage local (fichiers créés par l'app, journaux de crash), et le comportement en cas de coupure réseau — beaucoup d'apps conservent des données sensibles non chiffrées « en attendant la reconnexion ».

Un détail que j'ai mis longtemps à comprendre : sur Android, la sauvegarde automatique de l'app est activée par défaut sur beaucoup de versions récentes. Si l'app stocke un jeton dans un fichier, une sauvegarde locale peut le récupérer. Vérifiez les options de sauvegarde dans le manifeste, c'est une ligne à ajouter ou retirer.

Comment enlever la sécurité sur les applications ?

Je le disais en ouvrant : si vous cherchez à contourner la sécurité d'une application que vous ne possédez pas, arrêtez-vous là. Les règles d'usage des stores et plusieurs textes de loi encadrent cela, et « débloquer » une app pour en extraire des données n'est pas un test, c'est une intrusion.

Le seul cas légitime : votre propre application

Si l'app est la vôtre, « enlever la sécurité » n'a pas de sens. Ce qu'on fait, c'est isoler un environnement de test : un build de debug signé avec un certificat de test, un backend de recette, des identifiants factices, et un appareil dédié. On ne touche jamais à la version de production installée sur son téléphone personnel.

Le raccourci que j'ai honte d'avoir pris la première fois : tester sur ma version de prod avec mes vraies données, parce que « c'était plus rapide ». J'ai planté une migration de base en recette qui a failli partir en production. Depuis, j'ai un appareil de test dédié, avec un compte bidon, et c'est non négociable.

La fiche de contrôle avant publication : ce que je vérifie, dans l'ordre

Voici la séquence que j'applique pour toute app que je mets en ligne. Elle prend une journée, parfois deux. C'est le meilleur investissement de toute la mise en production.

  1. Analyse statique du paquet : décompiler l'APK ou l'IPA, chercher les chaînes sensibles, clés d'API, URLs internes.
  2. Analyse dynamique sur appareil réel : capture de trafic, inspection du stockage, journaux de crash.
  3. Test de l'API et du backend : vérifier que l'autorisation existe côté serveur, avec un compte bas de gamme.
  4. Test de stockage local : vérifier qu'aucun jeton, mot de passe ou donnée personnelle n'est écrit en clair.
  5. Vérification des SDK tiers : recouper le comportement observé avec ce que chaque SDK est censé collecter, et avec les déclarations de confidentialité du store.
  6. Relecture des déclarations de confidentialité : comparer ce que vous déclarez à ce que vous observez réellement dans le trafic. Si un SDK envoie un identifiant que vous n'avez pas déclaré, c'est vous qui êtes en tort, pas lui.

Le point 5 mérite un exemple. Sur mon app de suivi de dépenses, un SDK de statistiques intégré pour suivre les plantages envoyait aussi un identifiant publicitaire. Je ne l'avais pas déclaré dans la fiche du store. Ce n'était pas une faille au sens strict, mais un écart entre la déclaration et le comportement réel — exactement ce que le point 6 sert à attraper.

Dernier conseil, et c'est le plus utile : testez avec un appareil ancien. Un téléphone de plusieurs générations en arrière révèle souvent des comportements que votre modèle récent cache — chiffrement non disponible, API dépréciée, comportement différent en cas de perte de réseau. J'ai découvert une fois que mon app laissait en clair les données pendant un mode avion, sur une version d'Android que je n'avais pas testée.

La sécurité d'une application mobile avant publication, ce n'est pas une case à cocher sur une checklist. C'est une habitude de lecture du comportement — la vôtre, et celle de votre application. Et la vérité, c'est qu'on ne la trouve jamais totalement. On réduit la surface, on vérifie, on recommence à la version suivante.

Adeline POIRIER

Adeline POIRIER

Adeline Poirier est une experte reconnue en apprentissage automatique, en analyse de données massives et en visualisation de données. Elle accompagne depuis plusieurs années des équipes pluridisciplinaires dans la conception de modèles prédictifs performants et la mise en lumière d'insights complexes. Passionnée par la transmission, elle vulgarise avec rigueur et enthousiasme les enjeux des données à grande échelle.

Voir tous les articles →

Articles similaires