Sécurité des Agents IA : Ne Pas Faire Fuir les Secrets

Les agents IA de code (Gemini CLI, Claude Code, GitHub Copilot, Cursor) ont accès à votre filesystem, peuvent lire vos fichiers et exécuter des commandes. Cette surface d’attaque nécessite une hygiène de sécurité stricte.

Angle choisi : Défensif. Considérer que tout ce que l’agent lit peut potentiellement être exposé.

Le Périmètre de Risque

Ce Que Ces Agents Peuvent Voir

Gemini CLI / Claude Code / Cursor :

• Lecture complète du filesystem (permissions utilisateur)
• Historique des commandes shell
• Variables d’environnement
• Contenu des fichiers ouverts
• Résultats d’exécution de commandes

GitHub Copilot :

• Fichiers actuellement ouverts dans l’IDE
• Contexte du fichier (imports, fonctions voisines)
• Commentaires et docstrings

Capacités d’exécution :

# Gemini CLI / Claude Code peuvent exécuter
git log --all                    # Historique complet
cat ~/.ssh/id_rsa               # Clés SSH
env | grep -i secret            # Variables sensibles
curl https://api.internal/data  # Requêtes réseau

Si un agent lit un secret, il peut l’inclure dans sa requête au LLM cloud, où il sera logué, analysé, et potentiellement utilisé pour l’entraînement de futurs modèles.

Règle N°1 : Aucun Secret dans le Code

Ce Qui Ne Doit JAMAIS Être Commité

# ❌ INTERDIT - Credentials hardcodés
API_KEY = "sk-proj-abc123def456"
DATABASE_URL = "postgresql://admin:P@ssw0rd@prod-db:5432/main"
AWS_SECRET = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"

# ❌ INTERDIT - Tokens dans le code
headers = {
    "Authorization": "Bearer ghp_abc123def456ghi789"
}

# ❌ INTERDIT - Clés privées
PRIVATE_KEY = """
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA...
-----END RSA PRIVATE KEY-----
"""

La Bonne Approche : Variables d’Environnement

# ✅ CORRECT - Variables d'environnement
import os

API_KEY = os.getenv("API_KEY")
DATABASE_URL = os.getenv("DATABASE_URL")
AWS_SECRET = os.getenv("AWS_SECRET_ACCESS_KEY")

if not API_KEY:
    raise ValueError("API_KEY environment variable not set")

Fichier .env (JAMAIS commité) :

# .env - Local development only
API_KEY=sk-proj-abc123def456
DATABASE_URL=postgresql://admin:P@ssw0rd@localhost:5432/dev
AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

Fichier .env.example (commitable) :

# .env.example - Template for developers
API_KEY=your_api_key_here
DATABASE_URL=postgresql://user:password@localhost:5432/dbname
AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key

Règle N°2 : .gitignore Strict et Exhaustif

Template Sécurisé

Créer un .gitignore défensif avant toute interaction avec un agent IA :

# ========================================
# SECRETS & CREDENTIALS
# ========================================
.env
.env.*
!.env.example
*.key
*.pem
*.p12
*.pfx
*.cer
*.crt
secrets/
credentials/
config/secrets.yml
config/credentials.yml

# ========================================
# SSH & GPG
# ========================================
id_rsa
id_rsa.pub
id_ed25519
id_ed25519.pub
*.ppk
known_hosts

# ========================================
# CLOUD PROVIDER CREDENTIALS
# ========================================
.aws/credentials
.aws/config
.azure/
.gcloud/
terraform.tfvars
terraform.tfstate
terraform.tfstate.backup

# ========================================
# DATABASE DUMPS
# ========================================
*.sql
*.dump
*.backup
*.db

# ========================================
# LOGS (peuvent contenir des secrets)
# ========================================
*.log
logs/
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# ========================================
# IDE & EDITOR
# ========================================
.vscode/settings.json
.idea/
*.swp
*.swo
*~

# ========================================
# OS
# ========================================
.DS_Store
Thumbs.db

Vérification Automatique

Script de pre-commit pour détecter les secrets :

#!/bin/bash
# .git/hooks/pre-commit

# Patterns de secrets courants
PATTERNS=(
  'password\s*=\s*["\047][^"\047]+["\047]'
  'api[_-]?key\s*=\s*["\047][^"\047]+["\047]'
  'secret\s*=\s*["\047][^"\047]+["\047]'
  'token\s*=\s*["\047][^"\047]+["\047]'
  'AKIA[0-9A-Z]{16}'  # AWS Access Key
  'sk-[a-zA-Z0-9]{48}' # OpenAI API Key
  'ghp_[a-zA-Z0-9]{36}' # GitHub Personal Access Token
)

for pattern in "${PATTERNS[@]}"; do
  if git diff --cached | grep -iE "$pattern"; then
    echo "❌ SECRET DETECTED: Pattern '$pattern' found in staged files"
    echo "Commit blocked. Remove secrets before committing."
    exit 1
  fi
done

echo "✅ No secrets detected in staged files"
exit 0

Activer le hook :

chmod +x .git/hooks/pre-commit

Règle N°3 : Audit des Requêtes Agents IA

Ce Que l’Agent Envoie au Cloud

Quand vous utilisez Claude Code ou Gemini CLI, voici ce qui est transmis :

Requête vers l'API Claude/Gemini :
├─ Votre prompt utilisateur
├─ Fichiers lus par l'agent (contenu complet)
├─ Résultats des commandes exécutées
├─ Contexte de conversation précédent
└─ Métadonnées (timestamp, modèle, tokens)

Exemple de leak involontaire :

# Vous demandez : "Liste les fichiers du projet"
$ ls -la

# L'agent exécute et voit :
total 48
-rw-r--r-- 1 user user  245 Feb 11 10:30 .env          # ⚠️ Présence d'un .env
-rw-r--r-- 1 user user 1243 Feb 11 10:25 config.yml
-rw-r--r-- 1 user user 8192 Feb 11 09:15 backup.sql    # ⚠️ Dump de base de données

# Si vous demandez ensuite : "Lis le fichier .env"
# ❌ L'agent va lire et envoyer le contenu au LLM

Commandes à Éviter avec un Agent Actif

# ❌ NE PAS exécuter via un agent
cat .env
cat ~/.ssh/id_rsa
git log --all --oneline  # Peut contenir des secrets dans les messages
docker inspect <container>  # Variables d'environnement exposées
kubectl get secrets -o yaml
aws configure list
printenv | grep -i secret

# ✅ SAFE - Exécuter manuellement dans un terminal séparé

Règle N°4 : Isolation des Environnements

Principe de Moindre Privilège

Ne jamais utiliser un agent IA avec des credentials de production actifs.

# ❌ MAUVAIS - Environnement de production
export AWS_PROFILE=production
export DATABASE_URL=postgresql://admin:pass@prod-db:5432/main
claude-code  # ⚠️ L'agent a maintenant accès aux credentials prod

# ✅ BON - Environnement de développement isolé
export AWS_PROFILE=dev-sandbox
export DATABASE_URL=postgresql://dev:devpass@localhost:5432/dev_db
claude-code  # ✅ Credentials non-critiques

Workspace Dédié pour l’IA

Créer un répertoire de travail spécifique :

# Structure recommandée
~/projects/
├─ prod/              # Code de production (PAS d'agent IA)
│  ├─ .env           # Credentials production
│  └─ app/
└─ dev-ai/           # Workspace pour agents IA
   ├─ .env           # Credentials de dev uniquement
   └─ app/           # Clone du code

Workflow sécurisé :

1. Développer avec l’agent dans dev-ai/
2. Tester avec des credentials de dev
3. Code review manuel
4. Copier le code validé dans prod/
5. Déployer depuis prod/ sans agent actif

Règle N°5 : Review Systématique Avant Commit

Ce Qu’un Agent Peut Introduire

Les agents IA peuvent involontairement :

• Générer du code avec des vulnérabilités (SQL injection, XSS)
• Hardcoder des credentials de test qui ressemblent à de vrais secrets
• Inclure des URLs internes dans les commentaires
• Créer des backdoors non-intentionnels

Checklist avant chaque commit généré par IA :

# 1. Diff complet
git diff

# 2. Recherche de patterns sensibles
git diff | grep -iE '(password|secret|key|token|api)'

# 3. Recherche de credentials réels (regex)
git diff | grep -E 'AKIA[0-9A-Z]{16}|sk-[a-zA-Z0-9]{48}'

# 4. Vérification des URLs
git diff | grep -E 'https?://[^/]+' | grep -v 'github.com\|npmjs.com'

# 5. Analyse statique
trufflehog git file://. --only-verified

Outils de Détection de Secrets

TruffleHog (recommandé) :

# Installation
pip install trufflehog

# Scan du repo
trufflehog git file://. --json | jq

# Scan avant commit
trufflehog git file://. --since-commit HEAD

Gitleaks :

# Installation
brew install gitleaks

# Scan
gitleaks detect --source . --verbose

# Configuration .gitleaks.toml
[allowlist]
paths = [
  ".*test.*",
  ".*example.*"
]

GitGuardian (SaaS) :

• Monitoring continu des repos GitHub/GitLab
• Alertes en temps réel sur secrets détectés
• Intégration CI/CD

Règle N°6 : Logging et Audit Trail

Historique des Interactions Agent

Les agents conservent un historique de conversation. Auditer régulièrement :

Claude Code :

# Logs de session
~/.claude/logs/

# Historique des commandes
~/.claude/history/

Gemini CLI :

# Cache et historique
~/.config/gemini-cli/

# Vérifier les fichiers lus
grep -r "Read:" ~/.config/gemini-cli/

Nettoyage Périodique

# Supprimer les anciennes sessions
find ~/.claude -type f -mtime +30 -delete
find ~/.config/gemini-cli -type f -mtime +30 -delete

# Purger l'historique shell
history -c
rm ~/.bash_history

Règle N°7 : Configuration Réseau Restrictive

Limiter les Connexions Sortantes

Firewall pour bloquer les requêtes non-autorisées :

# UFW - Bloquer tout sauf les services essentiels
sudo ufw default deny outgoing
sudo ufw allow out 443/tcp  # HTTPS
sudo ufw allow out 80/tcp   # HTTP
sudo ufw enable

# Autoriser uniquement les endpoints IA légitimes
sudo ufw allow out to api.anthropic.com port 443
sudo ufw allow out to generativelanguage.googleapis.com port 443

Proxy de Filtrage

Utiliser un proxy pour auditer les requêtes :

# mitmproxy - Intercepter les requêtes HTTPS
mitmproxy --mode transparent --showhost

# Configurer l'agent pour utiliser le proxy
export HTTPS_PROXY=http://localhost:8080
claude-code

Avantage : Vous voyez en temps réel ce qui est envoyé au LLM.

Règle N°8 : Modèles Locaux pour le Code Sensible

Alternative : LLM Auto-Hébergé

Pour du code hautement sensible, utiliser des modèles locaux :

llama.cpp (pas d’envoi cloud) :

# Télécharger un modèle
wget https://huggingface.co/TheBloke/CodeLlama-13B-Instruct-GGUF/resolve/main/codellama-13b-instruct.Q4_K_M.gguf

# Lancer le serveur local
./server -m codellama-13b-instruct.Q4_K_M.gguf --host 0.0.0.0 --port 8080

# Continue.dev configuré sur localhost:8080
# ✅ Aucune donnée ne quitte votre machine

Ollama :

# Installation
curl -fsSL https://ollama.com/install.sh | sh

# Lancer un modèle de code
ollama run codellama:13b

# Configuration dans votre IDE
{
  "continue.apiBase": "http://localhost:11434",
  "continue.model": "codellama:13b"
}

Avantages :

• Aucune fuite de données
• Pas de coût API
• Latence réduite (si GPU local)

Inconvénients :

• Performances inférieures aux modèles cloud (GPT-4, Claude Opus)
• Nécessite du matériel puissant (GPU avec 16-24 GB VRAM minimum)

Règle N°9 : Sensibilisation de l’Équipe

Politique de Sécurité IA

Document à partager avec tous les développeurs :

# Politique d'Utilisation des Agents IA

## AUTORISÉ
- Utilisation sur du code open-source
- Génération de tests unitaires
- Refactoring de code non-sensible
- Documentation et commentaires

## INTERDIT
- Credentials de production
- Code propriétaire confidentiel
- Données personnelles (RGPD)
- Algorithmes brevetés
- Données client

## PROCÉDURE
1. Vérifier le .gitignore avant d'activer l'agent
2. Utiliser uniquement des credentials de dev
3. Review manuelle de 100% du code généré
4. Scan de secrets avant chaque commit
5. Purger l'historique agent après chaque session sensible

Formation Continue

• Workshop mensuel : Incidents de sécurité IA récents
• Simulation d’attaque : Red team teste l’exfiltration via agents IA
• Metrics : Tracker les détections de secrets par l’équipe

Cas d’Usage Réels et Incidents

Incident #1 : Fuite de Clé AWS

Scénario :

# Développeur utilise Copilot
# Fichier ouvert : deploy.sh

export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCY

# Copilot suggère la ligne suivante basée sur le contexte
aws s3 cp backup.sql s3://prod-backups/

Problème : La clé AWS est maintenant dans les logs de GitHub Copilot (envoyés à OpenAI pour améliorer le modèle).

Solution :

1. Rotation immédiate de la clé AWS
2. Audit des logs S3 pour détecter un usage non-autorisé
3. Mise en place d’un pre-commit hook
4. Formation de l’équipe

Incident #2 : URL Interne Exposée

Scénario :

# Claude Code génère du code de test
def test_api_endpoint():
    # Test against staging environment
    response = requests.get("https://api.internal.company.com/v1/users")
    assert response.status_code == 200

Problème : L’URL interne api.internal.company.com est maintenant dans les logs d’Anthropic.

Impact : Révèle l’existence d’une infrastructure interne (reconnaissance passive pour attaquant).

Solution :

1. Utiliser des variables d’environnement même pour les URLs
2. Nettoyer le code avant commit : remplacer par API_BASE_URL
3. Ne jamais exposer de sous-domaines internes

Checklist de Sécurité Agent IA

Avant chaque session :

[ ] .gitignore à jour et complet
[ ] Aucun fichier .env dans le répertoire de travail
[ ] Credentials de dev uniquement (pas de prod)
[ ] Workspace isolé (pas le repo principal)
[ ] Pre-commit hooks activés
[ ] Scan de secrets configuré (TruffleHog/Gitleaks)

Pendant la session :

[ ] Ne pas demander à l'agent de lire .env
[ ] Ne pas exécuter de commandes sensibles via l'agent
[ ] Vérifier chaque fichier lu par l'agent
[ ] Éviter les commandes qui exposent l'infra (kubectl, aws)

Après la session :

[ ] git diff complet avant commit
[ ] Recherche de patterns de secrets
[ ] Vérification manuelle de tout code généré
[ ] Scan automatique (trufflehog git file://.)
[ ] Purge de l'historique agent si session sensible

Outils et Scripts de Sécurité

Script de Nettoyage Post-Session

#!/bin/bash
# cleanup-ai-session.sh

echo "🔒 Nettoyage post-session agent IA..."

# 1. Purger l'historique shell
history -c
rm -f ~/.bash_history ~/.zsh_history

# 2. Nettoyer les logs agents
rm -rf ~/.claude/logs/*
rm -rf ~/.config/gemini-cli/cache/*

# 3. Supprimer les variables d'environnement sensibles
unset AWS_ACCESS_KEY_ID
unset AWS_SECRET_ACCESS_KEY
unset DATABASE_URL
unset API_KEY

# 4. Scanner le repo pour des secrets
echo "🔍 Scan de secrets..."
trufflehog git file://. --only-verified

# 5. Vérifier le .gitignore
echo "📋 Vérification .gitignore..."
if [ ! -f .gitignore ]; then
  echo "❌ .gitignore manquant !"
  exit 1
fi

if ! grep -q ".env" .gitignore; then
  echo "❌ .env non présent dans .gitignore !"
  exit 1
fi

echo "✅ Nettoyage terminé"

Script de Validation Pre-Commit

#!/bin/bash
# .git/hooks/pre-commit

# Couleurs
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'

echo "🔐 Validation de sécurité pré-commit..."

# 1. Détecter les secrets
echo "🔍 Recherche de secrets..."
if git diff --cached | grep -iE '(password|secret|key|token|api)["\047]?\s*[:=]\s*["\047]'; then
  echo -e "${RED}❌ SECRET DÉTECTÉ dans le code${NC}"
  exit 1
fi

# 2. Vérifier les extensions de fichiers sensibles
SENSITIVE_FILES=$(git diff --cached --name-only | grep -E '\.(pem|key|p12|pfx)$')
if [ ! -z "$SENSITIVE_FILES" ]; then
  echo -e "${RED}❌ FICHIER SENSIBLE détecté: $SENSITIVE_FILES${NC}"
  exit 1
fi

# 3. Vérifier la présence de .env
if git diff --cached --name-only | grep -q "^\.env$"; then
  echo -e "${RED}❌ TENTATIVE de commit de .env${NC}"
  exit 1
fi

# 4. Scanner avec TruffleHog
if command -v trufflehog &> /dev/null; then
  trufflehog git file://. --since-commit HEAD --only-verified --json > /tmp/trufflehog-results.json
  if [ -s /tmp/trufflehog-results.json ]; then
    echo -e "${RED}❌ SECRETS trouvés par TruffleHog${NC}"
    cat /tmp/trufflehog-results.json
    exit 1
  fi
fi

echo -e "${GREEN}✅ Validation réussie${NC}"
exit 0

Conclusion

L’utilisation d’agents IA pour le développement est un multiplicateur de productivité, mais nécessite une discipline de sécurité rigoureuse.

Principes fondamentaux :

1. Zéro Trust : Considérer que tout ce que l’agent lit peut être exposé
2. Isolation : Environnements de dev dédiés, credentials non-critiques
3. Validation : Review manuelle de 100% du code généré par IA
4. Automation : Pre-commit hooks, scans de secrets, CI/CD renforcée
5. Éducation : Formation continue de l’équipe sur les risques IA

Le coût d’une fuite de credentials :

• Rotation de toutes les clés compromises
• Audit des accès non-autorisés
• Impact réputationnel si exposition publique
• Coût financier potentiel (ressources cloud consommées par un attaquant)

L’investissement dans la sécurité :

• 2 heures de setup initial (hooks, .gitignore, outils)
• 5 minutes par commit (review + scan)
• 0€ de coût direct (outils open-source)

Le rapport bénéfice/risque est clair : les bonnes pratiques sont peu coûteuses à mettre en place, et les conséquences d’une négligence sont potentiellement catastrophiques.

Agents IA = Outils puissants. Sécurité = Non-négociable.