Applications mobiles

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

Une clé d'API oubliée a suffi à faire rejeter une app impeccable par Apple. Découvrez la méthode d'audit sécurité mobile avant publication qui évite les fuites classiques — et les semaines de retard.

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

Une app qui fonctionne parfaitement en simulateur, avec un code propre et une UI impeccable, peut se faire retoquer en quarante-huit heures par la review Apple. Pas pour un bug visuel. Pour une clé d'API oubliée dans un fichier de config. Ça m'est arrivé sur un projet de suivi d'activité physique, et c'est ce jour-là que j'ai compris une chose simple : un audit sécurité application mobile avant publication ne se joue pas sur les fonctionnalités, il se joue sur ce qui traîne dans les coins.

La question qu'on me pose le plus souvent, en atelier ou en fin de sprint, c'est : « on est prêts à publier ? ». Et dans 9 cas sur 10, la vraie réponse est non. Pas parce que l'app est mauvaise. Parce que personne n'a regardé à l'intérieur avec l'œil de quelqu'un qui cherche à casser quelque chose.

Ce qui suit, c'est la méthode que j'applique désormais, avec ses ratés et ses outils. Elle ne remplace pas un pentest sérieux si vous publiez une app bancaire. Mais elle vous évite de vous faire épingler sur des évidences.

Points clés à retenir

  • Un audit avant publication, c'est une revue de code statique + des tests dynamiques sur un vrai appareil, pas seulement une passe sur le simulateur.
  • Les trois fuites les plus courantes : secrets en dur dans le code, stockage local non chiffré, absence de certificate pinning.
  • OWASP MASVS et MASTG sont vos référentiels de travail — ils listent ce qu'il faut vérifier, plateforme par plateforme.
  • Les exigences des stores (Apple, Google) et le RGPD imposent déjà une partie du travail : autant s'y aligner volontairement.
  • Un audit raté m'a coûté deux semaines de retard de mise en production. Un bon audit m'a coûté trois jours.

Audit de sécurité mobile avant publication : ce qui se joue vraiment

Sur une app web, vous contrôlez le serveur. Sur mobile, l'appareil est chez l'utilisateur, souvent rooté ou jailbreaké, parfois instrumenté. Le code de votre app est téléchargeable par n'importe qui, décompilable, analysable. Le modèle de menaces change du tout au tout.

Un audit mobile, c'est donc l'évaluation de ce que l'app révèle et ce qu'elle permet quand un attaquant a l'appareil entre les mains. Trois grandes familles de problèmes en ressortent :

  • Ce que l'app embarque malgré elle (secrets, endpoints internes, clés de chiffrement)
  • Ce qu'elle écrit sur le disque (tokens, cache, logs de debug)
  • Ce qu'elle accepte de faire à l'exécution (injection, instrumentation, contournement de l'authentification)

Pourquoi « avant publication » et pas après

C'est l'angle qui manque dans la plupart des contenus sur le sujet. Après publication, chaque faille corrigée coûte une nouvelle version, une nouvelle review, une communication aux utilisateurs, parfois une notification à la CNIL. Avant, ça coûte un fichier à nettoyer et deux heures de test.

Un chiffre qui m'a marqué : sur une de mes apps publiées en 2023, une mauvaise configuration du stockage local exposait les tokens de session dans un fichier accessible par simple sauvegarde iTunes. Détecté six semaines après la sortie. Correction en 2 heures. Mais il a fallu pousser une mise à jour, attendre la review, et révoquer tous les tokens côté serveur. Un audit en amont aurait coûté, au pire, une demi-journée.

Comment réaliser un audit d'application ?

Un audit d'application, dans le sens pratique du terme, c'est une revue méthodique qui évalue la sécurité, la qualité du code, la performance et la conformité de l'app. On la mène en quatre phases, et on ne saute pas la première.

Comment réaliser un audit d'application ?

Phase 1 : cadrage et liste de contrôle

Avant de toucher à un outil, on définit le périmètre. Quelles données l'app manipule-t-elle ? Des données de santé, de paiement, de géolocalisation ? Le niveau d'exigence en dépend. Une app de recettes de cuisine n'a pas les mêmes obligations qu'une app de santé connectée.

  • Inventaire des données collectées et de leur sensibilité
  • Identification des flux réseau (API, SDK tiers, analytics, crash reporting)
  • Sélection de la checklist de référence — MASVS pour le socle, plus les règles store
  • Définition des critères de go/no-go avant soumission

Phase 2 : analyse statique (SAST)

Là, on passe le code au crible sans l'exécuter. Outils de SAST pour détecter les motifs dangereux, scanners de secrets pour repérer les clés en dur, analyse du binaire pour voir les chaînes de caractères sensibles qui restent dans l'APK ou l'IPA.

Concrètement, un scan basique sur une de mes apps a remonté 4 secrets en clair : une clé d'API Google Maps, un token d'un service de newsletter, une clé S3, et un mot de passe de base de test. Trois sur quatre n'auraient jamais dû être dans le binaire.

Phase 3 : tests dynamiques (DAST)

On exécute l'app, sur un appareil réel, avec instrumentation. C'est là qu'on teste le comportement à l'exécution : interception du trafic, tentative de contournement du SSL pinning, inspection du stockage local, modification de la mémoire.

Les outils qui reviennent tout le temps : Frida pour l'instrumentation, Objection pour les manipulations rapides, un proxy type Burp ou mitmproxy pour intercepter les échanges, MobSF pour un scan automatisé de base.

Phase 4 : rapport et décision

Un audit qui ne produit pas une liste hiérarchisée de correctifs est un audit inutile. On classe : bloquant, important, à surveiller. Et on décide collectivement du go/no-go.

Mon critère, et je le défends : zéro bloquant avant de soumettre. Pas de « on corrigera dans la v1.1 ». La v1.1, elle arrive dans six semaines. Six semaines, c'est long pour un attaquant.

Comment réaliser un audit de sécurité ?

L'audit de sécurité est le cœur du travail. Il a sa propre grille, différente de l'audit général. Voici comment je le mène, dans l'ordre.

Comment réaliser un audit de sécurité ?

Vérifier ce que l'app écrit

Le stockage local est le premier coupable. Les tokens d'authentification doivent aller dans le Keychain (iOS) ou le Keystore (Android). Pas dans les SharedPreferences, pas dans un fichier en clair, pas dans une base SQLite sans chiffrement. Sur Android, l'activation du chiffrement des backups est une case à cocher que beaucoup oublient.

Autre point : les logs. En production, une app ne doit pas logguer un token, un mot de passe, un identifiant de session. Point. J'ai déjà vu une app qui affichait le token JWT complet dans Logcat en mode debug, et le laissait passer en release. C'est une faille qui ne saute pas aux yeux.

Vérifier ce que l'app transmet

Le réseau, c'est là que la plupart des attaques faciles se jouent. Trois contrôles essentiels :

  • Certificate pinning actif sur les endpoints critiques, pour empêcher l'interception par un proxy
  • Pas de HTTP en clair — TLS partout, y compris sur les endpoints secondaires qu'on oublie souvent
  • Authentification correcte côté serveur, pas seulement côté client

Vérifier ce que l'app accepte

Enfin, la résistance à l'instrumentation. Sur un appareil rooté/jailbreaké, l'app doit-elle refuser de s'exécuter ? La réponse n'est pas toujours oui (certaines apps fonctionnent très bien pour des utilisateurs légitimes en environnement modifié), mais il faut que ce soit une décision consciente, pas un oubli.

Comment faire pour sécuriser une application ?

Sécuriser une app après publication, c'est réparer. Sécuriser avant, c'est anticiper. Voici les chantiers concrets, dans l'ordre où je les traiterais si je devais repartir de zéro sur une app existante.

Les correctifs à prioriser

  1. Sortir tous les secrets du code. Les mettre dans des variables d'environnement côté build, ou dans un gestionnaire de secrets (Vault, AWS Secrets Manager).
  2. Chiffrer le stockage local. Keychain pour iOS, Android Keystore pour Android, et vérifier que les backups ne contiennent rien de sensible.
  3. Imposer TLS partout, activer le certificate pinning sur les endpoints critiques.
  4. Retirer tous les logs de debug en release. Les builds de production ne doivent pas logguer d'informations sensibles.
  5. Vérifier les dépendances : une bibliothèque tierce obsolète peut introduire une faille connue.

Le cas du certificate pinning

Un exemple concret, parce que c'est le point qui fâche. Sur mon app de suivi d'activité, j'avais activé le pinning en pensant être tranquille. Sauf que j'avais épinglé un certificat qui expirait dans douze mois. Douze mois plus tard, tous les utilisateurs de la dernière version se sont retrouvés avec une app qui ne se connectait plus. Zéro avertissement côté store. Juste des avis à une étoile qui tombaient.

Leçon : le pinning, c'est bien, mais il faut une stratégie de rotation. Soit épingler la clé publique (moins fragile que le certificat), soit prévoir une mise à jour forcée bien avant l'expiration.

Comment savoir si une application est sécurisée ?

C'est la question à un million, et honnêtement, la réponse est toujours la même : « ça dépend ». Aucune app n'est « sécurisée » dans l'absolu. Il y a des apps plus ou moins résistantes à des menaces identifiées.

Ce qu'on peut dire, c'est qu'une app est raisonnablement sécurisée quand elle passe les contrôles suivants, et je les ai regroupés dans un tableau pour y voir plus clair :

Contrôle Critère de validation Outil / méthode
Secrets dans le code Aucun secret en dur dans le binaire Scanner de secrets, analyse de l'APK/IPA
Stockage local Tokens dans Keychain/Keystore, données sensibles chiffrées Inspection manuelle, MobSF
Transport réseau TLS partout, pinning actif et rotatif Proxy d'interception, Frida
Authentification Vérifiée côté serveur, résistante à l'instrumentation Tests manuels, Objection
Dépendances Aucune bibliothèque obsolète connue pour une faille critique Audit de dépendances, SCA
Conformité store Privacy manifest, règles Apple/Google respectées Checklist éditeur

Un audit externe par un tiers reste la seule façon d'avoir un avis honnête. Sur une app à forts enjeux, c'est non négociable. Sur une app de niche, un audit interne bien mené avec la bonne méthode suffit souvent.

Les questions à se poser avant de soumettre

  • Mon app fonctionne-t-elle correctement sur un appareil rooté ou jailbreaké, et est-ce le comportement attendu ?
  • Est-ce que je peux intercepter mon propre trafic sans que l'app ne m'en empêche ?
  • Que lit un attaquant qui décompile mon APK ?
  • Quels sont mes logs en mode release ?
  • Mes critères de go/no-go sont-ils documentés, ou est-ce que je décide « au feeling » ?

Une dernière chose. Un audit sécurité mobile avant publication n'est pas un événement ponctuel. C'est un rituel. À chaque nouvelle feature, à chaque nouvelle dépendance, à chaque nouvelle version du SDK, on remet un peu de la grille sur le métier. Sur les projets que je suis, on a intégré une passe de checklist dans la Definition of Done depuis deux ans. Ça a réduit les incidents post-publication de manière très nette, et surtout, ça a arrêté de faire de la sécurité un sujet qu'on traitait « quand on aurait le temps ».

Parce qu'on ne trouve pas le temps. On le prend. Et il vaut mieux le prendre avant que l'app soit sur l'App Store, plutôt qu'après.

Marion Baudry

Marion Baudry

Marion Baudry est reconnue pour son expertise en cybersécurité et en protection des données. Avec une approche innovante et une passion pour la sécurité numérique, elle contribue à protéger les informations sensibles dans un monde en constante évolution.

Voir tous les articles →

Articles similaires