KappS Base de connaissances · FAQ

Obfuscation du code et protection contre la rétro-ingénierie sur Google Play

FAQ Sécurité

1. Ce que Google demande réellement. Les recommandations de Google ne sont pas « obscurcissez pour cacher des secrets » : elles disent « minifiez et obscurcissez pour rendre la rétro-ingénierie plus coûteuse, et gardez les véritables contrôles de sécurité sur votre serveur ». La documentation de build Android (https://developer.android.com/build/shrink-code) décrit R8 comme le réducteur de code par défaut du plugin Gradle Android : il effectue en une seule passe l'élagage de l'arbre, la réduction des ressources, l'optimisation et le renommage des identifiants (obscurcissement), et Google précise clairement que « l'obscurcissement n'est pas en soi une fonctionnalité de sécurité » : il augmente le coût d'une rétro-ingénierie occasionnelle mais ne rend pas un client digne de confiance. Le guide de sécurité pour les développeurs (https://developer.android.com/privacy-and-security/security-best-practices) dit la même chose sous un autre angle : ne livrez jamais de secrets, de clés d'API ou de logique côté serveur dans l'APK, car tout ce qui se trouve sur l'appareil peut être lu.

2. Activez R8 pour les builds de release. Dans le build.gradle(.kts) de votre module d'application, le type de build release doit définir minifyEnabled true (c'est R8, compatible avec ProGuard) et shrinkResources true, et référencer proguard-rules.pro. La réduction des ressources supprime les ressources inutilisées et ne fonctionne que si minifyEnabled est également activé. R8 utilise le fichier de règles par défaut optimisé (proguard-android-optimize.txt) : au-delà de la réduction, il applique donc aussi des optimisations comme l'inlining de méthodes, la fusion de classes et la suppression des arguments inutilisés. Vérifiez l'effet en comparant la taille des artefacts debug et release et en lisant build/outputs/mapping/release/mapping.txt.

3. Les règles keep sont la source de la plupart des plantages en release. R8 renomme et supprime tout ce qu’il estime inatteignable — y compris les types dont il ne peut pas voir qu’ils sont utilisés par réflexion. Les coupables habituels sont les parseurs JSON (classes de données Gson/Moshi/Jackson), les interfaces Retrofit et leurs modèles @SerializedName, les entités Room, kotlinx.serialization, ViewBinding/DataBinding, Parcelable, les vues personnalisées gonflées en XML et tout ce qui est chargé par nom de classe (Class.forName, JNI, service loaders). Les symptômes en production sont NoSuchMethodException, ClassNotFoundException, des champs JSON vides ou renommés, ou un plantage qui ne survient qu’en release et jamais en debug. Ajoutez des règles -keep ciblées (par exemple -keep class com.example.model.** { *; } pour les DTO, -keepclassmembers pour les champs @SerializedName) plutôt que -keep tout, et testez toujours le build release, pas seulement le debug. Kotlin a souvent besoin de -keepclassmembers class **$WhenMappings plus des règles de métadonnées ; AndroidX embarque ses propres règles consommateur que R8 fusionne automatiquement.

4. Importez mapping.txt pour que les rapports de plantage restent lisibles. R8 génère build/app/outputs/mapping/release/mapping.txt (ainsi que configuration.txt et seeds.txt). Importez ce fichier avec la version dans Play Console, ou faites-le faire par votre pipeline de publication, afin que Play Console désobfusque les traces de pile et les ANR pour vous. Sans cela, chaque plantage en production ressemble à a.a.a.b(Unknown Source) et vous perdez la capacité de triage. Conservez le mapping de chaque version que vous publiez — une version reconstruite nécessite un nouveau fichier de mapping.

5. Ne confiez jamais la décision de sécurité au client. C’est l’erreur de conception la plus fréquente : embarquer un indicateur isPremium / LicenseValid / IsTampered que l’application évalue localement. Tout ce que le client décide, le client peut le modifier — un changement d’un octet avec apktool ou un hook Frida suffit à inverser l’indicateur. Déplacez la décision vers votre backend : l’application doit envoyer des preuves (un jeton, un jeton d’achat, un verdict d’intégrité) et le serveur doit décider. Concrètement, vérifiez les achats Google Play Billing côté serveur avec l’API Play Developer (purchases.subscriptionsv2 / purchases.products) au lieu de faire confiance à l’accusé de réception sur l’appareil, et considérez toute « vérification de licence » qui ne quitte jamais l’appareil comme un décor, pas une protection.

6. L’API Play Integrity est le moyen pris en charge d’obtenir ce verdict côté serveur. L’API Play Integrity (https://developer.android.com/google/play/integrity) remplace l’API SafetyNet Attestation, désormais dépréciée. Votre application l’appelle et reçoit un verdict d’intégrité chiffré, signé et à durée de vie courte, qui doit être déchiffré et vérifié par les serveurs de Google (ou par votre backend qui appelle l’API Play Integrity) — jamais sur l’appareil. Le verdict contient des signaux d’intégrité de l’appareil (MEETS_BASIC_INTEGRITY / MEETS_DEVICE_INTEGRITY / MEETS_STRONG_INTEGRITY), un signal d’intégrité de l’application (le binaire correspond à ce que vous avez téléversé, ce qui détecte les APK reconditionnés ou modifiés) et des signaux de compte et de licence (PLAY_RECOGNITION / LICENSED). Privilégiez les requêtes Standard (recommandées) aux requêtes Classic, qui relèvent du flux historique. Vous configurez l’API pour votre application dans Play Console sous Intégrité de l’application et pouvez y suivre le taux d’échec des verdicts. Un verdict en échec est un signal, pas une preuve : Google déconseille de laisser un seul appareil défaillant décider, alors recherchez les schémas et les anomalies de taux et ne bloquez pas les utilisateurs honnêtes. Le quota quotidien de requêtes évolue avec le nombre d’installations (10 000/jour par défaut) et des limites plus élevées s’obtiennent via le formulaire lié depuis https://support.google.com/googleplay/android-developer/answer/11395166.

7. Signature, détection de falsification et protection en un clic de Play. Deux niveaux. (a) Signature de l’application : les applications modernes utilisent le schéma de signature APK v2/v3 (v4 pour une installation rapide). Avec Play App Signing, Google détient la clé de signature de l’application tandis que vous conservez la clé de téléversement, si bien qu’un keystore volé ne signifie plus une application détournée, et la clé de téléversement peut être renouvelée. Vous pouvez comparer au runtime le certificat de l’application à celui attendu, mais gardez à l’esprit que ce contrôle est lui-même patchable — utilisez-le comme signal côté serveur. (b) La protection automatique de Google Play (« Protected with Play », https://support.google.com/googleplay/android-developer/answer/13857328) est un interrupteur Play Console en un clic qui intègre à l’application une détection anti-falsification et anti-piratage au runtime et signale lorsqu’un binaire installé ne correspond pas à la version du store ; elle ne nécessite aucune intégration backend de votre part. Associez-la au verdict d’intégrité de l’application Play Integrity plutôt que de compter sur l’une ou l’autre seule.

8. Durcissez le client, mais partez du principe qu’il sera lu. Au-delà de l’obfuscation : gardez debuggable à false et supprimez android:debuggable ; retirez les logs en release (R8 peut supprimer Log.d via -assumenosideeffects, ou augmentez le niveau de log) ; ne codez pas en dur les clés d’API, jetons ou endpoints — récupérez-les et faites-les tourner à l’exécution ; stockez les clés côté appareil dans le Keystore Android (https://developer.android.com/privacy-and-security/keystore) au lieu de les intégrer ; ajoutez l’épinglage de certificat/clé publique pour qu’un faux serveur ou un proxy MITM ne puisse pas piloter votre application ; traitez la détection de root/émulateur/débogueur comme un simple signal indicatif (facilement contourné, mais il augmente le coût et arrête le script moyen) ; obfusquez ou chiffrez les constantes de chaînes à forte valeur (endpoints, feature flags) avec l’obfuscation de chaînes R8 ou un outil de durcissement commercial quand l’actif le justifie ; et déplacez la logique sensible vers le NDK/code natif uniquement si vous acceptez la complexité de build — le natif est plus difficile, pas impossible, à reverser.

9. La dimension politique : clones, repackaging et les limites de l’obfuscation. Obfusquer sa propre application est légitime et encouragé ; utiliser l’obfuscation pour dissimuler un comportement contraire aux politiques lors de l’examen de Google ne l’est pas. La Developer Program Policy de Google (https://support.google.com/googleplay/android-developer/answer/17190352) ainsi que ses politiques Malware (https://support.google.com/googleplay/android-developer/answer/9888380), Mobile Unwanted Software (https://support.google.com/googleplay/android-developer/answer/9970222) et Deceptive Behavior (https://support.google.com/googleplay/android-developer/answer/16680223) interdisent les applications trompeuses, qui dissimulent la collecte de données ou des fonctionnalités, ou qui font un usage abusif des données de l’appareil, du réseau ou personnelles ; une application qui ne fonctionne que parce que son comportement est caché échoue à l’examen et, si elle est découverte après la mise en ligne, est retirée. À l’inverse, une protection client faible est précisément ce qui permet à d’autres de repackager votre application, de contourner votre facturation ou de la cloner : ce sont ces mêmes pages de politiques que vous citez lorsque vous déposez un signalement pour atteinte à la propriété intellectuelle ou pour logiciel malveillant contre une contrefaçon, et les règles de Play en matière d’usurpation d’identité et de copie couvrent les imitations qui reprennent votre identité. Signalez les clones contrefaisants ou malveillants via le formulaire de plainte pour propriété intellectuelle du Play Console et les canaux de signalement prévus par les politiques.

10. Auto-audit par décompilation avant publication (à faire une fois par version). (1) Générez l'AAB/APK de version officielle. (2) Pointez apktool/JADX sur l'artefact de version officielle - pas de débogage - et lisez la sortie décompilée : confirmez qu'aucun nom de classe/méthode lisible n'expose la logique métier et qu'aucun secret en clair ne subsiste. (3) Passez l'APK au grep pour vos clés API, endpoints, 'Bearer ', 'password', 'secret', 'http://' et indicateurs de débogage (par exemple strings assets/* | grep -i key). (4) Lancez Frida sur un appareil de test rooté et tentez les attaques de deux minutes - basculez votre indicateur de licence/premium, hookez l'appel d'intégrité, lisez le stockage local ; tout ce qui réussit doit passer côté serveur. (5) Confirmez que mapping.txt a été produit et téléversé pour cette version. (6) Confirmez que Play Integrity et/ou Protected with Play est activé et que votre backend rejette réellement un verdict en échec. Si l'obfuscation est votre seul contrôle, considérez les données et la logique premium de l'application comme publiques.