Que fait Audit de Fuites Client Public ?
Auditez un client public qui communique avec un backend privé. Objectif : la surface publique doit être autonome — elle peut révéler les appels qu'elle effectue et les formes de données qu'elle échange (inévitables pour tout client livré), mais rien de plus. Tout détail supplémentaire sur le fonctionnement du serveur constitue une reconnaissance gratuite pour un attaquant et un levier d'abus.
Ce skill produit trois choses : une liste de constats (fuites + failles côté client, chacune avec fichier:ligne et sévérité), un ensemble de correctifs appliqués, et un rapport avec des recommandations résiduelles.
Fichiers de référence (chargez à la demande — lisez celui dont vous avez besoin, ne les incorporez pas tous) :
references/leak-taxonomy.md— les catégories de divulgation à traquer, pourquoi chacune compte, et des motifs de recherche initiaux.references/rewrite-rules.md— la règle de réécriture des commentaires/chaînes avec exemples avant/après ; comment décider de garder ou couper.references/client-hardening.md— la checklist de durcissement côté client (permissions, IPC, jetons, DOM, réseau, configuration de build, chaîne d'approvisionnement).references/report-template.md— la structure du rapport de sortie.scripts/leak-sweep.sh— un balayage ripgrep paramétré pour amorcer la recherche (personnalisez les tableaux de motifs par produit).
Le modèle mental central
Classez chaque divulgation dans l'un des deux buckets :
- Minimum nécessaire (garder) : les points de terminaison que le client appelle, les formes requête/réponse qu'il envoie et reçoit effectivement, ses propres choix de tentative/repli/débounce, les limites de validation d'entrée, et le mapping
statut → comportement UI. Un client public ne peut pas cacher cela ; prétendre le contraire est du théâtre de sécurité. - Sur-divulgation (corriger) : tout ce qui décrit ce que le serveur fait avec une requête, les limites/quotas côté serveur dont le client n'a pas strictement besoin, les points de terminaison que le client livré n'appelle jamais, les branches d'erreur qui reflètent la logique interne du serveur, les mécanismes anti-abus, les identifiants d'infrastructure/pile technique, les chemins/dépôts privés, et l'échafaudage de test qui encode le comportement du backend.
La règle de réécriture. Le code client et les tests peuvent énoncer le contrat ("HTTP 422 → afficher le message fournisseur non pris en charge"). Ils ne doivent pas expliquer ce que ou pourquoi le serveur le fait ("le serveur exécute une vérification de domaine jetable et rejette avec 422"). Quand un commentaire explique le comportement du serveur, supprimez-le ou réduisez-le au contrat observable par le client. Voir references/rewrite-rules.md.
Flux de travail
Adaptez l'effort à la demande : un rapide "est-ce que cela fuit quelque chose" correspond aux phases 1–2 ; "nettoyer avant open-sourcing" ou "audit complet" correspond aux six phases. Pour une grande base de code, déployez la phase 2 sur des agents parallèles en lecture seule (un par cluster de taxonomie) et fusionnez leurs constats fichier:ligne — mais faites d'abord vous-même le cadrage de la phase 1.
Phase 1 — Délimiter la frontière public/privé
Avant de chercher, établissez ce que "privé" signifie pour ce produit. Ne sautez pas cette étape — tout l'audit est relatif à cette frontière.
- Identifiez le ou les artefacts publics sous audit et leurs homologues privés (backend, outils d'administration, infrastructure, frères de monorepo). Demandez à l'utilisateur ou inférez à partir d'un fichier
AGENTS.md/README/CONTRIBUTINGsi la séparation n'est pas évidente. - Listez la pile backend du produit, son hébergement, sa base de données, ses mécanismes anti-abus, et toute facilité de test/recette — afin de reconnaître une fuite quand vous en voyez une. Si vous ne les connaissez pas, c'est la première question à poser à l'utilisateur.
- Écrivez ce qui constitue le minimum nécessaire pour ce client (ses véritables points de terminaison et charges utiles) afin de ne pas perdre de temps à signaler l'inévitable.
Phase 2 — Balayage des fuites
Parcourez la taxonomie dans references/leak-taxonomy.md. Couvrez tout le dépôt, pas seulement src/ : tests/e2e, docs, README/CHANGELOG, fichiers CI/workflow, .env* et leurs jumeaux .example, fichiers de build/config, manifests de paquets (scripts, postinstall), et chaînes de locale/i18n (elles sont livrées dans le paquet). Lancez scripts/leak-sweep.sh <répertoire-cible> comme balayage de départ, puis lisez les résultats dans leur contexte — une correspondance de motif est une piste, pas un verdict. Pour chaque constat réel, enregistrez fichier:ligne, une courte citation, et une raison en une clause. Tenez également une liste "vérifié, propre" pour que le rapport montre la couverture.
Portez une attention particulière à deux classes de grande valeur et faciles à manquer :
- Secrets à un pas de la publication — valeurs réelles dans des fichiers
.env*ignorés par git qu'un bundle source (zip de "sources révisables" du store/app-store,npm pack, une sauvegarde de répertoire) inclurait car le bundler ne respecte pas.gitignore. Non suivi ≠ sûr. - Code de test/e2e — identifiants de test déterministes, paramètres de requête spéciaux, points de terminaison que le client livré n'appelle jamais, et commentaires narrant les internes du serveur. C'est là que les fuites du comportement backend se produisent le plus souvent, car les tests documentent les réponses attendues du serveur.
Phase 3 — Durcissement côté client
Exécutez references/client-hardening.md. Ceci est orthogonal aux fuites : il s'agit de la possibilité d'exploiter le client indépendamment de ce qu'il divulgue. Priorisez la validation de l'expéditeur/origine sur l'IPC privilégié, le stockage et la sortie des jetons d'authentification, les puits DOM/XSS alimentés par des données provenant de la page ou du serveur, les permissions trop larges, et la configuration de build qui permettrait à un build empoisonné de rediriger le backend ou d'intégrer un secret.
Phase 4 — Remédiation
Appliquez les correctifs. Ordre d'impact :
- Fermez d'abord les canaux de fuite de secrets (excluez les fichiers
.env*/secret des bundles source ; déplacez les valeurs réelles hors des fichiers adjacents aux commits). - Appliquez la règle de réécriture aux commentaires/chaînes/docs qui fuient ; préférez renommer le code pour qu'un commentaire devienne inutile plutôt que de reformuler le commentaire.
- Supprimez le code mort qui code en dur la politique du serveur (TTL de session, quotas, points de terminaison supprimés).
- Taillez les tests/docs au contrat observable par le client ; gardez le flux fonctionnel, coupez la narration.
- Intégrez les changements de durcissement avec des tests.
La préservation du comportement est la valeur par défaut : gardez les contrats d'API publique, les clés de stockage, les noms de messages et les formes requête/réponse stables sauf si la tâche demande explicitement un changement fonctionnel.
Phase 5 — Vérification
Prouvez que vous n'avez rien cassé et n'avez rien oublié :
- Exécutez la vérification de types, les tests unitaires, le lint et une build de production du projet. Capturez les vrais codes de sortie (un tube
cmd | tailrapporte le statut detail, masquant une build échouée — exécutez sans le tube ou utilisezPIPESTATUS/set -o pipefail). - Relancez le balayage des fuites ; confirmez que les motifs visés sont maintenant à zéro (sauf ceux délibérés).
- Scannez l'artefact construit et tout bundle source à la recherche de secrets, sourcemaps et chaînes internes — grep
dist//sortie de build et le zip des sources. Ne vous fiez pas uniquement à la propreté de l'arbre source. - Confirmez que les flux légitimes fonctionnent toujours (par exemple, une build de recette/e2e qui est autorisée à différer se résout toujours correctement).
Phase 6 — Rapport
Rédigez le rapport selon references/report-template.md : constats par sévérité, changements appliqués, recommandations résiduelles (rotation des secrets, exposition dans l'historique git, compromis délibérément différés), et les preuves de vérification. Notez que l'historique git n'est pas réparable rétroactivement — un secret supprimé ou un sujet de commit descriptif reste dans le journal ; recommandez une rotation et une hygiène future des messages de commit plutôt qu'une réécriture de l'historique d'un dépôt public.
Garde-fous
- Ne signalez pas trop l'inévitable. Les points de terminaison, les formes de charge utile et les mappings
statut → UIconstituent le minimum nécessaire ; les signaler érode la confiance dans le rapport. - Une correspondance de motif est une piste. Lisez-la dans son contexte avant de la qualifier de fuite — "epoch" est généralement un timestamp, "worker" pourrait être un Web Worker, "durable" pourrait être une file d'attente, pas Durable Objects.
- Conservez les chaînes destinées à l'utilisateur qui énoncent une politique pertinente pour l'utilisateur (par exemple, "les codes expirent dans 10 minutes") ; supprimez le cadrage interne dans la description/commentaire non visible à côté.
- Ce skill audite votre propre code / code autorisé pour réduire sa surface d'attaque publique. Il est défensif : réduire la divulgation et durcir le client, pas construire des exploits.