protect-mcp — Application des politiques + Reçus signés

Gouvernance cryptographique pour chaque appel d'outil Claude Code. Chaque invocation est évaluée par rapport à une politique Cedar et produit un reçu signé Ed25519 que n'importe qui peut vérifier hors ligne.

Aperçu

Claude Code exécute des outils puissants : Bash, Edit, Write, WebFetch. Par défaut, il n'y a aucune piste d'audit, aucune application de politique, et aucun moyen de prouver ce qui a été décidé après coup. protect-mcp comble ces trois lacunes :

• Politiques Cedar (moteur d'autorisation ouvert d'AWS) qui évaluent chaque appel d'outil avant exécution. Le refus Cedar est autoritaire.
• Reçus Ed25519 qui enregistrent chaque décision avec ses entrées, la politique qui l'a régie, et le résultat. Les reçus sont enchaînés par hash.
• Vérification hors ligne via npx @veritasacta/verify. Pas de serveur, pas de compte, pas de confiance envers l'opérateur.

Problème

Les agents IA prennent des décisions qui affectent l'argent, la sécurité et les droits. Le journal de session Claude Code enregistre ce qui s'est passé, mais le journal est :

• Mutable — n'importe qui ayant accès peut le modifier
• Non signé — il n'existe aucun moyen de prouver l'intégrité
• Lié à l'opérateur — la vérification nécessite de faire confiance à celui qui détient le journal

Pour les contextes de conformité (finance, santé, recherche réglementée), ce n'est pas suffisant. Vous avez besoin de preuves évidentes de falsification qui peuvent être vérifiées par des tiers sans vous faire confiance.

Solution

Ajoutez protect-mcp à votre projet Claude Code :

# 1. Installer le plugin (ajoute des hooks + skill à votre projet)
claude plugin install wshobson/agents/protect-mcp

# 2. Configurer les hooks dans .claude/settings.json (voir ci-dessous)

# 3. Démarrer le serveur de signature des reçus (s'exécute localement, aucun appel externe)
npx protect-mcp@latest serve --enforce

# 4. Utiliser Claude Code normalement. Chaque appel d'outil est désormais évalué par la politique
#    et produit un reçu signé dans ./receipts/

Configuration des hooks

Ajoutez ce qui suit au fichier .claude/settings.json de votre projet :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": ".*",
        "hook": {
          "type": "command",
          "command": "npx protect-mcp@latest evaluate --policy ./protect.cedar --tool \"$TOOL_NAME\" --input \"$TOOL_INPUT\" || exit 2"
        }
      }
    ],
    "PostToolUse": [
      {
        "matcher": ".*",
        "hook": {
          "type": "command",
          "command": "npx protect-mcp@latest sign --tool \"$TOOL_NAME\" --input \"$TOOL_INPUT\" --output \"$TOOL_OUTPUT\" --receipts ./receipts/"
        }
      }
    ]
  }
}

Ce que fait chaque hook

PreToolUse — S'exécute AVANT l'exécution de l'outil. Évalue l'appel d'outil par rapport à votre fichier politique Cedar. Si Cedar retourne deny, le hook se termine avec le code 2 et Claude Code bloque complètement l'appel d'outil.

PostToolUse — S'exécute APRÈS la fin de l'outil. Signe un reçu contenant le nom de l'outil, le hash d'entrée, le hash de sortie, la décision, le condensé de la politique, et l'horodatage. Écrit le reçu dans ./receipts/<timestamp>.json.

Fichier de politique Cedar

Créez ./protect.cedar à la racine du projet :

// Autoriser les outils en lecture seule par défaut
permit (
    principal,
    action in [Action::"Read", Action::"Glob", Action::"Grep", Action::"WebFetch"],
    resource
);

// Exiger une autorisation explicite pour les outils destructifs
permit (
    principal,
    action == Action::"Bash",
    resource
) when {
    // Autoriser les commandes sûres uniquement
    context.command_pattern in ["git", "npm", "ls", "cat", "echo", "pwd", "test"]
};

// Ne jamais autoriser la suppression récursive
forbid (
    principal,
    action == Action::"Bash",
    resource
) when {
    context.command_pattern == "rm -rf"
};

// Exiger une confirmation pour les écritures en dehors du projet
forbid (
    principal,
    action in [Action::"Edit", Action::"Write"],
    resource
) when {
    context.path_starts_with != "."
};

Vérification

Vérifier un seul reçu :

npx @veritasacta/verify receipts/2026-04-15T10-30-00Z.json
# Exit 0 = valide
# Exit 1 = falsifié
# Exit 2 = malformé

Vérifier la chaîne entière :

npx @veritasacta/verify receipts/*.json

Utilisez les commandes slash du plugin depuis Claude Code :

/verify-receipt receipts/latest.json
/audit-chain ./receipts/ --last 20

Format du reçu

Chaque reçu est un fichier JSON avec cette structure :

{
  "receipt_id": "rec_8f92a3b1",
  "receipt_version": "1.0",
  "issuer_id": "claude-code-protect-mcp",
  "event_time": "2026-04-15T10:30:00.000Z",
  "tool_name": "Bash",
  "input_hash": "sha256:a3f8...",
  "decision": "allow",
  "policy_id": "autoresearch-safe",
  "policy_digest": "sha256:b7e2...",
  "parent_receipt_id": "rec_3d1ab7c2",
  "public_key": "4437ca56815c0516...",
  "signature": "4cde814b7889e987..."
}

• Signatures Ed25519 (RFC 8032)
• Canonicalisation JCS (RFC 8785) avant signature
• Enchaînement par hash au reçu précédent via parent_receipt_id
• Vérifiable hors ligne — aucun appel réseau, aucune recherche auprès du fournisseur

Pourquoi c'est important

Standards

• Ed25519 — RFC 8032 (signatures numériques)
• JCS — RFC 8785 (canonicalisation JSON déterministe)
• Cedar — langage de politique d'autorisation ouvert d'AWS
• IETF draft — draft-farley-acta-signed-receipts

Ressources connexes

• npm: protect-mcp (v0.5.5, 10 000+ téléchargements mensuels)
• CLI de vérification: @veritasacta/verify
• Source: github.com/ScopeBlind/scopeblind-gateway
• Protocole: veritasacta.com
• Intégrations: Microsoft Agent Governance Toolkit (PR #667), AWS cedar-policy/cedar-for-agents (PR #64)