Communitygithub.com

Audit de Fuites Client Public

Un skill pour agents IA. Audite un client public (extension, application, SPA, CLI, SDK) pour y détecter des fuites d'informations internes du backend, des secrets et des vulnérabilités exploitables, puis le renforce avant l'open-sourcing ou la soumission à un store.

Qu'est-ce que Audit de Fuites Client Public ?

Ce skill permet à un agent IA de réaliser un audit complet de sécurité d'un client public qui communique avec un backend privé. L'objectif est de s'assurer que la surface publique est autonome : elle peut révéler les appels effectués et les formes de données échangées (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. Le skill produit trois livrables : une liste de constats (fuites et failles côté client, avec fichier:ligne et sévérité), un ensemble de correctifs appliqués, et un rapport avec des recommandations résiduelles. Il repose sur six phases : 1) délimiter la frontière public/privé, 2) balayer les fuites à l'aide d'une taxonomie et d'un script ripgrep paramétré, 3) effectuer un durcissement côté client, 4) remédier aux problèmes (priorité aux secrets, commentaires, code mort), 5) vérifier (types, tests, build, re-balayage), 6) rédiger un rapport structuré. Le skill est conçu pour les agents utilisant Claude Code, Cursor ou Codex, et s'applique à tout projet client : extension navigateur, application mobile, SPA, CLI, SDK. Il inclut des fichiers de référence (taxonomie des fuites, règles de réécriture, checklist de durcissement, template de rapport) et un script bash de balayage. Le modèle mental central distingue le 'minimum nécessaire' (à garder) de la 'sur-divulgation' (à corriger). Les guardrails empêchent le sur-signalement et rappellent de lire chaque résultat dans son contexte.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add khasky/public-client-leak-audit

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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) :

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/CONTRIBUTING si 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 :

  1. 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).
  2. 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.
  3. Supprimez le code mort qui code en dur la politique du serveur (TTL de session, quotas, points de terminaison supprimés).
  4. Taillez les tests/docs au contrat observable par le client ; gardez le flux fonctionnel, coupez la narration.
  5. 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 | tail rapporte le statut de tail, masquant une build échouée — exécutez sans le tube ou utilisez PIPESTATUS/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 → UI constituent 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.

Skills associés