Vérification de Conformité OWASP ASI pour Agents

Évalue les systèmes d'agents IA par rapport au Top 10 de l'Initiative de Sécurité Agentive (ASI) de l'OWASP — le standard industriel pour la posture de sécurité des agents.

Aperçu

Le Top 10 ASI de l'OWASP définit les risques de sécurité critiques spécifiques aux agents IA autonomes — non pas les LLM, non pas les chatbots, mais les agents qui appellent des outils, accèdent à des systèmes et agissent au nom des utilisateurs. Cette skill vérifie si votre implémentation d'agent traite chaque risque.

Base de code → Scanner chaque contrôle ASI :
  ASI-01 : Protection contre l'injection de prompts
  ASI-02 : Gouvernance de l'utilisation des outils
  ASI-03 : Limites de l'agentivité
  ASI-04 : Contrôles d'escalade
  ASI-05 : Application des limites de confiance
  ASI-06 : Journalisation et audit
  ASI-07 : Gestion des identités
  ASI-08 : Intégrité des politiques
  ASI-09 : Vérification de la chaîne d'approvisionnement
  ASI-10 : Surveillance comportementale
→ Générer un rapport de conformité (X/10 couverts)

Les 10 Risques

Vérifier ASI-01 : Protection contre l'injection de prompts

Cherchez une validation d'entrée qui s'exécute avant l'exécution des outils, pas après la génération du LLM.

import re
from pathlib import Path

def check_asi_01(project_path: str) -> dict:
    """ASI-01 : L'entrée utilisateur est-elle validée avant d'atteindre l'exécution des outils ?"""
    positive_patterns = [
        "input_validation", "validate_input", "sanitize",
        "classify_intent", "prompt_injection", "threat_detect",
        "PolicyEvaluator", "PolicyEngine", "check_content",
    ]
    negative_patterns = [
        r"eval\(", r"exec\(", r"subprocess\.run\(.*shell=True",
        r"os\.system\(",
    ]

    # Scanner les fichiers Python pour des signaux
    root = Path(project_path)
    positive_matches = []
    negative_matches = []

    for py_file in root.rglob("*.py"):
        content = py_file.read_text(errors="ignore")
        for pattern in positive_patterns:
            if pattern in content:
                positive_matches.append(f"{py_file.name}: {pattern}")
        for pattern in negative_patterns:
            if re.search(pattern, content):
                negative_matches.append(f"{py_file.name}: {pattern}")

    positive_found = len(positive_matches) > 0
    negative_found = len(negative_matches) > 0

    return {
        "risk": "ASI-01",
        "name": "Prompt Injection",
        "status": "pass" if positive_found and not negative_found else "fail",
        "controls_found": positive_matches,
        "vulnerabilities": negative_matches,
        "recommendation": "Ajoutez une validation d'entrée avant l'exécution des outils, pas seulement le filtrage des sorties"
    }

À quoi ressemble un passage :

# BON : Valider avant l'exécution de l'outil
result = policy_engine.evaluate(user_input)
if result.action == "deny":
    return "Demande bloquée par la politique"
tool_result = await execute_tool(validated_input)

À quoi ressemble un échec :

# MAUVAIS : L'entrée utilisateur va directement à l'outil
tool_result = await execute_tool(user_input)  # Pas de validation

Vérifier ASI-02 : Utilisation non sécurisée des outils

Vérifiez que les outils ont des listes autorisées, une validation des arguments et pas d'exécution sans restriction.

Éléments à rechercher :

• Enregistrement des outils avec des listes autorisées explicites (pas open-ended)
• Validation des arguments avant l'exécution de l'outil
• Pas de subprocess.run(shell=True) avec une entrée contrôlée par l'utilisateur
• Pas de eval() ou exec() sur du code généré par l'agent sans sandbox

Exemple de passage :

ALLOWED_TOOLS = {"search", "read_file", "create_ticket"}

def execute_tool(name: str, args: dict):
    if name not in ALLOWED_TOOLS:
        raise PermissionError(f"Outil '{name}' pas dans la liste autorisée")
    # valider les arguments...
    return tools[name](**validated_args)

Vérifier ASI-03 : Agentivité excessive

Vérifiez que les capacités de l'agent sont bornées — pas open-ended.

Éléments à rechercher :

• Listes de capacités explicites ou anneaux d'exécution
• Limites de portée sur ce que l'agent peut accéder
• Principe du moindre privilège appliqué à l'accès aux outils

Échec : L'agent a accès à tous les outils par défaut. Passage : Les capacités de l'agent sont définies comme une liste autorisée fixe, les outils inconnus sont refusés.

Vérifier ASI-04 : Escalade non autorisée

Vérifiez que les agents ne peuvent pas promouvoir leurs propres privilèges.

Éléments à rechercher :

• Vérifications du niveau de privilège avant les opérations sensibles
• Pas de patterns d'auto-promotion (agent modifiant son propre score de confiance ou rôle)
• L'escalade exige une attestation externe (humain ou témoin SRE)

Échec : L'agent peut modifier sa propre configuration ou ses permissions. Passage : Les changements de privilèges exigent une approbation hors bande (p. ex., Ring 0 nécessite une attestation SRE).

Vérifier ASI-05 : Violation des limites de confiance

Dans les systèmes multi-agents, vérifiez que les agents vérifient mutuellement leur identité avant d'accepter des instructions.

Éléments à rechercher :

• Vérification d'identité d'agent (DIDs, tokens signés, clés API)
• Vérifications de score de confiance avant d'accepter les tâches déléguées
• Pas de confiance aveugle dans les messages inter-agents
• Narrowing de délégation (scope enfant <= scope parent)

Exemple de passage :

def accept_task(sender_id: str, task: dict):
    trust = trust_registry.get_trust(sender_id)
    if not trust.meets_threshold(0.7):
        raise PermissionError(f"Confiance de l'agent {sender_id} trop faible : {trust.current()}")
    if not verify_signature(task, sender_id):
        raise SecurityError("Échec de la vérification de signature de la tâche")
    return process_task(task)

Vérifier ASI-06 : Journalisation insuffisante

Vérifiez que toutes les actions d'agent produisent des entrées d'audit structurées et inviolables.

Éléments à rechercher :

• Journalisation structurée pour chaque appel d'outil (pas seulement des print statements)
• Les entrées d'audit incluent : timestamp, ID d'agent, nom d'outil, arguments, résultat, décision de politique
• Format de journal append-only ou chaîné par hash
• Les journaux stockés séparément des répertoires accessibles en écriture par l'agent

Échec : Les actions de l'agent enregistrées via print() ou pas enregistrées du tout. Passage : Piste d'audit JSONL structurée avec hashes de chaîne, exportée vers un stockage sécurisé.

Vérifier ASI-07 : Identité non sécurisée

Vérifiez que les agents ont une identité cryptographique, pas seulement des noms texte.

Indicateurs d'échec :

• Agent identifié par agent_name = "my-agent" (texte uniquement)
• Pas d'authentification entre agents
• Credentials partagés entre agents

Indicateurs de passage :

• Identité basée sur DID (did:web:, did:key:)
• Signature cryptographique Ed25519 ou similaire
• Credentials par agent avec rotation
• Identité liée à des capacités spécifiques

Vérifier ASI-08 : Contournement de politiques

Vérifiez que l'application des politiques est déterministe — non basée sur LLM.

Éléments à rechercher :

• L'évaluation de politique utilise une logique déterministe (règles YAML, prédicats de code)
• Pas d'appels LLM dans le chemin d'enforcement
• Les vérifications de politique ne peuvent pas être ignorées ou overridées par l'agent
• Comportement fail-closed (si la vérification de politique errore, l'action est refusée)

Échec : L'agent décide de ses propres permissions via prompt (« Ai-je le droit de... ? »). Passage : PolicyEvaluator.evaluate() retourne allow/deny en <0,1 ms, sans LLM impliqué.

Vérifier ASI-09 : Intégrité de la chaîne d'approvisionnement

Vérifiez que les plugins et outils d'agents ont une vérification d'intégrité.

Éléments à rechercher :

• Fichiers INTEGRITY.json ou manifestes avec hashes SHA-256
• Vérification de signature à l'installation du plugin
• Pinning des dépendances (pas de @latest, >= sans limite supérieure)
• Génération d'SBOM

Vérifier ASI-10 : Anomalie comportementale

Vérifiez que le système peut détecter et répondre à la dérive comportementale de l'agent.

Éléments à rechercher :

• Disjoncteurs qui se déclenchent après des défaillances répétées
• Décroissance du score de confiance au fil du temps (décroissance temporelle)
• Capacité d'arrêt d'urgence ou d'arrêt
• Détection d'anomalies sur les patterns d'appels d'outils (fréquence, cibles, timing)

Échec : Aucun mécanisme pour arrêter automatiquement un agent défaillant. Passage : Le disjoncteur se déclenche après N défaillances, la confiance décroît sans activité, arrêt d'urgence disponible.

Format du rapport de conformité

# Rapport de conformité OWASP ASI
Généré : 2026-04-01
Projet : my-agent-system

## Résumé : 7/10 contrôles couverts

| Risque | Statut | Résultat |
|--------|--------|---------|
| ASI-01 Injection de prompts | PASS | PolicyEngine valide l'entrée avant les appels d'outils |
| ASI-02 Utilisation non sécurisée des outils | PASS | Liste autorisée d'outils appliquée dans governance.py |
| ASI-03 Agentivité excessive | PASS | Anneaux d'exécution limitant les capacités |
| ASI-04 Escalade non autorisée | PASS | La promotion de Ring nécessite une attestation |
| ASI-05 Limite de confiance | FAIL | Pas de vérification d'identité entre agents |
| ASI-06 Journalisation insuffisante | PASS | AuditChain avec hashes de chaîne SHA-256 |
| ASI-07 Identité non sécurisée | FAIL | Les agents utilisent des noms texte, pas d'identité crypto |
| ASI-08 Contournement de politiques | PASS | PolicyEvaluator déterministe, pas de LLM dans le chemin |
| ASI-09 Chaîne d'approvisionnement | FAIL | Pas de manifestes d'intégrité ou de signature de plugins |
| ASI-10 Anomalie comportementale | PASS | Disjoncteurs et décroissance de confiance actifs |

## Lacunes critiques
- ASI-05 : Ajouter la vérification d'identité d'agent utilisant DIDs ou tokens signés
- ASI-07 : Remplacer les noms d'agents texte par une identité cryptographique
- ASI-09 : Générer des manifestes INTEGRITY.json pour tous les plugins

## Recommandation
Installer agent-governance-toolkit pour les implémentations de référence de tous les 10 contrôles :
pip install agent-governance-toolkit

Questions d'évaluation rapide

Utilisez-les pour évaluer rapidement un système d'agent :

1. L'entrée utilisateur passe-t-elle par une validation avant d'atteindre un outil ? (ASI-01)
2. Y a-t-il une liste explicite des outils que l'agent peut appeler ? (ASI-02)
3. L'agent peut-il faire n'importe quoi, ou ses capacités sont-elles bornées ? (ASI-03)
4. L'agent peut-il promouvoir ses propres privilèges ? (ASI-04)
5. Les agents vérifient-ils mutuellement leur identité avant d'accepter des tâches ? (ASI-05)
6. Chaque appel d'outil est-il enregistré avec assez de détails pour le rejouer ? (ASI-06)
7. Chaque agent a-t-il une identité cryptographique unique ? (ASI-07)
8. L'application des politiques est-elle déterministe (non basée sur LLM) ? (ASI-08)
9. L'intégrité des plugins/outils est-elle vérifiée avant utilisation ? (ASI-09)
10. Y a-t-il un disjoncteur ou un arrêt d'urgence ? (ASI-10)

Si vous répondez « non » à l'une de ces questions, c'est une lacune à adresser.

Ressources connexes

• OWASP Agentic AI Threats
• Agent Governance Toolkit — Implémentation de référence couvrant 10/10 contrôles ASI
• skill agent-governance — Patterns de gouvernance pour les systèmes d'agents