Garde-fou : masquer clés d'API et mots de passe

Garde-fou qui masque clés d'API, jetons, mots de passe, clés privées et chaînes de connexion avant d'envoyer un texte, un fichier ou un export à une IA. Règles, 14 cas de test, code.

Règles

Masquer avant l'envoi à l'IA tout secret qui donne accès à un compte ou à un service :
- clés d'API (OpenAI, Anthropic, Mistral, Stripe, AWS…) et jetons d'accès (GitHub, JWT) ;
- mots de passe écrits en clair (mot_de_passe=…, password: …) ;
- clés privées (-----BEGIN … PRIVATE KEY-----) ;
- identifiants dans une adresse (postgres://utilisateur:motdepasse@serveur).
Laisser passer : les valeurs d'exemple (VOTRE_CLE, xxx, <clé>), les adresses sans identifiant, les identifiants de commande ou de commit, le texte qui parle de mots de passe sans en contenir.
À appliquer avant de coller un fichier .env, un export de base ou des journaux dans un assistant.

Cas de test

Code

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|mot_de_passe|mdp)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "votre", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Remplace les secrets par [type masqué] ; renvoie le texte et True si quelque chose a été masqué."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} masqué]"
        text = re.sub(pattern, repl, text)
    return text, found

Identifiant

contextetech--masquer-secrets-cles-api

Fichier

masquer-secrets-cles-api.guardrail.json

Format

JSON (application/json)

Taille

2 645 octets (2,6 Ko)

Encodage

UTF-8

Tokens estimés

≈ 726

Usage commercial

Autorisé

Données personnelles

Aucune

Version

1.0

Publié le

10 octobre 2026 à 04:24

Mis à jour le

16 octobre 2026 à 23:20

Stockage

en base

Coût estimé

Tokens d'entrée par appel

≈ 1 073

Coût d'entrée seulement, sans la réponse du modèle. Prix publics des fournisseurs (Mistral AI, DeepSeek, OpenAI, Anthropic), tarif standard en dollars converti en euros au taux BCE du 13 octobre 2026. Estimation : 1 token ≈ 3,6 caractères.

masquer-secrets-cles-api.guardrail.json

{
  "format": "contextetech/guardrail/v1",
  "id": "contextetech/masquer-secrets-cles-api",
  "description": "Garde-fou qui masque clés d'API, jetons, mots de passe, clés privées et chaînes de connexion avant d'envoyer un texte, un fichier ou un export à une IA. Règles, 14 cas de test, code.",
  "license": "MIT",
  "language": "fr",
  "type": "other",
  "action": "mask",
  "rules": "Masquer avant l'envoi à l'IA tout secret qui donne accès à un compte ou à un service :\n- clés d'API (OpenAI, Anthropic, Mistral, Stripe, AWS…) et jetons d'accès (GitHub, JWT) ;\n- mots de passe écrits en clair (mot_de_passe=…, password: …) ;\n- clés privées (-----BEGIN … PRIVATE KEY-----) ;\n- identifiants dans une adresse (postgres://utilisateur:motdepasse@serveur).\nLaisser passer : les valeurs d'exemple (VOTRE_CLE, xxx, <clé>), les adresses sans identifiant, les identifiants de commande ou de commit, le texte qui parle de mots de passe sans en contenir.\nÀ appliquer avant de coller un fichier .env, un export de base ou des journaux dans un assistant.",
  "cases": [
    {
      "input": "AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE",
      "expected": "block"
    },
    {
      "input": "token: ghp_000000000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "ANTHROPIC_API_KEY=sk-ant-00000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "STRIPE_SECRET=sk_live_0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "DATABASE_URL=postgres://admin:S3cretPass@db.internal:5432/app",
      "expected": "block"
    },
    {
      "input": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA0000000000000000\n-----END RSA PRIVATE KEY-----",
      "expected": "block"
    },
    {
      "input": "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIwMDAwMDAifQ.0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "mot_de_passe = Soleil2026!",
      "expected": "block"
    },
    {
      "input": "Le mot de passe doit faire au moins 12 caractères.",
      "expected": "allow"
    },
    {
      "input": "Remplacez VOTRE_CLE_API par la clé de votre compte.",
      "expected": "allow"
    },
    {
      "input": "La documentation est sur https://docs.exemple.fr/api.",
      "expected": "allow"
    },
    {
      "input": "Le commit a1b2c3d corrige le bug de connexion.",
      "expected": "allow"
    },
    {
      "input": "Commande n° 2026-10-458712 expédiée.",
      "expected": "allow"
    },
    {
      "input": "Connectez-vous avec votre compte habituel.",
      "expected": "allow"
    }
  ]
}

Vérifier un texte (Python)

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|mot_de_passe|mdp)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "votre", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Remplace les secrets par [type masqué] ; renvoie le texte et True si quelque chose a été masqué."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} masqué]"
        text = re.sub(pattern, repl, text)
    return text, found