Introduction : Pourquoi l'Alignment et la Sécurité API sont Essentiels
En tant que développeur senior qui a intégré plus de 47 API d'IA différentes au cours des cinq dernières années, je peux vous assurer que la sécurité et l'alignement des modèles ne sont plus des options — c'est une nécessité absolue. Les failles de sécurité, les dérives comportementales des modèles et les coûts cachés peuvent transformer votre projet en cauchemar opérationnel. Après avoir testé des dizaines de fournisseurs, j'ai trouvé une solution qui répond à tous ces défis : s'inscrire ici sur HolySheep AI.
Tableau Comparatif : HolySheep vs API Officielle vs Services Relais
| Critère | HolySheep AI | API Officielle | Autres Services Relais |
|---|---|---|---|
| Prix GPT-4.1 | ¥33/1M tokens ($8) | $60/1M tokens | $10-15/1M tokens |
| Prix Claude Sonnet 4.5 | ¥112/1M tokens ($15) | $3/1M tokens | $8-12/1M tokens |
| Prix Gemini 2.5 Flash | ¥18/1M tokens ($2.50) | $0.30/1M tokens | $1.50-3/1M tokens |
| Prix DeepSeek V3.2 | ¥3/1M tokens ($0.42) | N/A | $0.80-1.20/1M tokens |
| Latence Moyenne | <50ms | 150-300ms | 80-200ms |
| Paiement | WeChat/Alipay/Carte | Carte internationale | Limité |
| Crédits Gratuits | ✅ Oui | ❌ Non | ⚠️ Variable |
| Économie vs Official | 85%+ | Référence | 20-50% |
Qu'est-ce que l'AI Alignment ?
L'alignment IA (AI Alignment) désigne l'ensemble des techniques permettant de s'assurer qu'un modèle d'intelligence artificielle behave conformément aux intentions humaines et aux valeurs éthiques souhaitées. En pratique, cela se traduit par :
- La cohérence des réponses : Le modèle doit produire des résultats prévisibles et cohérents avec le contexte fourni.
- La sécurité des sorties : Éviter la génération de contenus nuisibles, malveillants ou inappropriés.
- Le respect des consignes : Le modèle doit suivre précisément les instructions de l'utilisateur.
- La robustesse aux injections : Resistance aux attaques de type prompt injection.
Architecture Sécurisée avec HolySheep AI
Principes Fondamentaux
Mon expérience personnelle m'a appris que la sécurité d'une API IA repose sur quatre piliers essentiels :
- Chiffrement de bout en bout : Toutes les communications doivent être chiffrées avec TLS 1.3 minimum.
- Validation des entrées : Chaque prompt doit être sanitis before être envoyé au modèle.
- Rate limiting intelligent : Prévenir les abus tout en permettant une expérience utilisateur fluide.
- Monitoring en temps réel : Détecter les comportements anormaux instantanément.
Implémentation Pratique : Code Complet
1. Configuration de Base avec Python
"""
Sécurité API avec HolySheep AI - Configuration de Base
Auteur: Équipe HolySheep AI
Version: 2.0.0
"""
import os
import hashlib
import hmac
import time
from typing import Optional, Dict, Any
from dataclasses import dataclass
from datetime import datetime, timedelta
@dataclass
class HolySheepConfig:
"""Configuration sécurisée pour HolySheep AI"""
api_key: str = "YOUR_HOLYSHEEP_API_KEY"
base_url: str = "https://api.holysheep.ai/v1"
timeout: int = 30
max_retries: int = 3
rate_limit: int = 100 # requêtes par minute
class SecureAIConnection:
"""
Classe de connexion sécurisée à HolySheep AI.
Inclut la validation des entrées et la gestion des erreurs.
"""
def __init__(self, config: HolySheepConfig):
self.config = config
self.request_history: list = []
self._validate_config()
def _validate_config(self) -> None:
"""Valide la configuration avant utilisation"""
if not self.config.api_key or self.config.api_key == "YOUR_HOLYSHEEP_API_KEY":
raise ValueError("⚠️ Clé API invalide ou placeholder détecté")
if not self.config.base_url.startswith("https://"):
raise ValueError("⚠️ URL doit utiliser HTTPS pour la sécurité")
if "api.openai.com" in self.config.base_url or "api.anthropic.com" in self.config.base_url:
raise ValueError("⚠️ URLs officielles interdites - utilisez HolySheep AI")
def sanitize_prompt(self, prompt: str) -> str:
"""Nettoie le prompt pour prévenir les injections"""
dangerous_patterns = [
"ignore previous instructions",
"disregard all previous",
"you are now",
"system prompt",
"admin mode",
"sudo",
]
sanitized = prompt
for pattern in dangerous_patterns:
if pattern.lower() in prompt.lower():
sanitized = sanitized.replace(pattern, "[FILTRÉ]")
return sanitized
def check_rate_limit(self) -> bool:
"""Vérifie si la limite de requêtes est respectée"""
now = datetime.now()
one_minute_ago = now - timedelta(minutes=1)
self.request_history = [
req for req in self.request_history
if req > one_minute_ago
]
if len(self.request_history) >= self.config.rate_limit:
return False
self.request_history.append(now)
return True
Exemple d'utilisation
config = HolySheepConfig()
connection = SecureAIConnection(config)
print("✅ Connexion sécurisée initialisée")
print(f"📡 Endpoint: {config.base_url}")
2. Implémentation de l'Alignment avec System Prompts
"""
Module d'Alignment IA avec HolySheep AI
Implémente les principes RLHF et Constitutional AI
"""
import json
from typing import List, Dict, Optional
from enum import Enum
class SafetyLevel(Enum):
"""Niveaux de sécurité pour les réponses"""
STRICT = "strict" # Aucun contenu potentiellement nuisible
MODERATE = "moderate" # Balance entre sécurité et utilité
PERMISSIVE = "permissive" # Plus de liberté (usage avancé)
class AlignmentManager:
"""
Gère l'alignment des modèles IA selon les principes de sécurité.
Utilise des techniques de Constitutional AI et RLHF simplifiées.
"""
def __init__(self, safety_level: SafetyLevel = SafetyLevel.MODERATE):
self.safety_level = safety_level
self.constitutional_principles = self._load_constitutional_principles()
self.output_validator = OutputValidator()
def _load_constitutional_principles(self) -> List[str]:
"""Charge les principes constitutionnels de base"""
return [
"Respecter la vie privée et ne jamais révéler d'informations personnelles",
"Refuser toute demande de génération de contenu nuisible ou illégal",
"Maintenir l'honnêteté et ne jamais falsifier des informations",
"Éviter les biais et traiter tous les sujets avec équité",
"Préférer la clarté et la précision dans les réponses"
]
def build_system_prompt(self, user_context: Optional[str] = None) -> str:
"""Construit un system prompt optimisé pour l'alignment"""
base_prompt = """Tu es un assistant IA sécurisé et éthique.
Tu dois toujours :
1. Répondre de manière utile, précise et respectueuse
2. Refuser poliment les demandes inappropriées ou dangereuses
3. Admettre quand tu ne sais pas quelque chose
4. Proposer des alternatives constructives quand c'est possible
Principes de comportement :
"""
for i, principle in enumerate(self.constitutional_principles, 1):
base_prompt += f"{i}. {principle}\n"
if user_context:
base_prompt += f"\nContexte utilisateur à respecter :\n{user_context}\n"
if self.safety_level == SafetyLevel.STRICT:
base_prompt += "\n⚠️ Mode STRICT activé : réponses ultra-conservatrices"
elif self.safety_level == SafetyLevel.PERMISSIVE:
base_prompt += "\n⚠️ Mode PERMISSIVE : assumes bonnes intentions de l'utilisateur"
return base_prompt
def validate_output(self, response: str) -> Dict[str, any]:
"""Valide la sortie du modèle selon les critères de sécurité"""
validation_result = {
"is_safe": True,
"warnings": [],
"sanitized_response": response
}
# Vérifications de sécurité
dangerous_keywords = [
"comment créer une bombe",
"tutoriel piratage",
"produire de la drogue",
"instructions violence"
]
response_lower = response.lower()
for keyword in dangerous_keywords:
if keyword in response_lower:
validation_result["is_safe"] = False
validation_result["warnings"].append(
f"Contenu potentiellement dangereux détecté : '{keyword}'"
)
validation_result["sanitized_response"] = (
"[Contenu filtré pour des raisons de sécurité]"
)
return validation_result
def create_alignment_request(
self,
user_message: str,
context: Optional[str] = None
) -> Dict[str, any]:
"""
Crée une requête alignée avec validation complète.
C'est la méthode principale à utiliser.
"""
aligned_request = {
"messages": [
{"role": "system", "content": self.build_system_prompt(context)},
{"role": "user", "content": user_message}
],
"safety_check": True,
"alignment_version": "2.0"
}
return aligned_request
Démonstration
alignment_manager = AlignmentManager(safety_level=SafetyLevel.MODERATE)
system_prompt = alignment_manager.build_system_prompt()
print("✅ System prompt d'alignment généré")
print(f"📏 Longueur: {len(system_prompt)} caractères")
test_request = alignment_manager.create_alignment_request(
user_message="Explique-moi le fonctionnement d'Internet",
context="Utilisateur en formation développement web"
)
print(f"✅ Requête alignée créée avec {len(test_request['messages'])} messages")
3. Intégration Complète avec la Route API
"""
Intégration complète HolySheep AI avec Flask/FastAPI
Inclut rate limiting, logging et gestion d'erreurs avancée
"""
from flask import Flask, request, jsonify
import hashlib
import time
import logging
from functools import wraps
from datetime import datetime
app = Flask(__name__)
Configuration HolySheep
HOLYSHEEP_CONFIG = {
"base_url": "https://api.holysheep.ai/v1",
"api_key": "YOUR_HOLYSHEEP_API_KEY",
"default_model": "gpt-4.1",
"temperature": 0.7,
"max_tokens": 2048
}
Logging configuration
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger('HolySheepAPI')
Rate limiting simple (en production, utiliser Redis)
request_counts = {}
RATE_LIMIT_WINDOW = 60 # secondes
MAX_REQUESTS_PER_WINDOW = 100
def rate_limit_decorator(f):
"""Décorateur pour limiter les requêtes par IP"""
@wraps(f)
def decorated_function(*args, **kwargs):
client_ip = request.remote_addr or "unknown"
current_time = time.time()
# Nettoyage des anciennes entrées
if client_ip in request_counts:
request_counts[client_ip] = [
t for t in request_counts[client_ip]
if current_time - t < RATE_LIMIT_WINDOW
]
else:
request_counts[client_ip] = []
# Vérification de la limite
if len(request_counts[client_ip]) >= MAX_REQUESTS_PER_WINDOW:
logger.warning(f"⚠️ Rate limit atteint pour {client_ip}")
return jsonify({
"error": "Rate limit exceeded",
"retry_after": RATE_LIMIT_WINDOW
}), 429
request_counts[client_ip].append(current_time)
return f(*args, **kwargs)
return decorated_function
def verify_api_signature(request_data: dict, signature: str) -> bool:
"""Vérifie la signature de la requête pour une authentification renforcée"""
if not signature:
return False
# En production, utiliser une clé secrète partagée
expected_sig = hashlib.sha256(
f"{request_data}{HOLYSHEEP_CONFIG['api_key']}".encode()
).hexdigest()
return hmac.compare_digest(signature, expected_sig)
@app.route('/api/v1/chat', methods=['POST'])
@rate_limit_decorator
def chat_completion():
"""
Endpoint principal pour les complétions de chat.
Transmet de manière sécurisée à HolySheep AI.
"""
try:
data = request.get_json()
if not data or 'messages' not in data:
return jsonify({
"error": "Format invalide",
"required_fields": ["messages"]
}), 400
# Validation des messages
messages = data['messages']
if not isinstance(messages, list) or len(messages) == 0:
return jsonify({
"error": "messages doit être une liste non vide"
}), 400
# Construction de la requête HolySheep
holy_request = {
"model": data.get('model', HOLYSHEEP_CONFIG['default_model']),
"messages": messages,
"temperature": data.get('temperature', HOLYSHEEP_CONFIG['temperature']),
"max_tokens": data.get('max_tokens', HOLYSHEEP_CONFIG['max_tokens']),
"stream": data.get('stream', False)
}
logger.info(f"📤 Requête vers HolySheep: {holy_request['model']}")
# Simulation de l'appel API (remplacer par httpx/requests réel)
# En production :
# response = requests.post(
# f"{HOLYSHEEP_CONFIG['base_url']}/chat/completions",
# headers={
# "Authorization": f"Bearer {HOLYSHEEP_CONFIG['api_key']}",
# "Content-Type": "application/json"
# },
# json=holy_request,
# timeout=HOLYSHEEP_CONFIG.get('timeout', 30)
# )
return jsonify({
"success": True,
"endpoint_used": HOLYSHEEP_CONFIG['base_url'],
"request_id": hashlib.md5(str(time.time()).encode()).hexdigest(),
"message": "Requête validée et prête pour HolySheep AI"
}), 200
except Exception as e:
logger.error(f"❌ Erreur: {str(e)}")
return jsonify({
"error": "Erreur interne",
"details": str(e)
}), 500
@app.route('/api/v1/health', methods=['GET'])
def health_check():
"""Endpoint de santé pour monitorer le service"""
return jsonify({
"status": "healthy",
"provider": "HolySheep AI",
"base_url": HOLYSHEEP_CONFIG['base_url'],
"timestamp": datetime.utcnow().isoformat()
}), 200
@app.route('/api/v1/usage', methods=['GET'])
def get_usage():
"""Retourne les statistiques d'utilisation"""
total_requests = sum(len(v) for v in request_counts.values())
return jsonify({
"period": "last_60_seconds",
"total_requests": total_requests,
"unique_ips": len(request_counts),
"rate_limit_per_ip": MAX_REQUESTS_PER_WINDOW,
"provider": "HolySheep AI"
}), 200
if __name__ == '__main__':
print("🚀 Démarrage du serveur API sécurisé HolySheep")
print(f"📡 Endpoint: {HOLYSHEEP_CONFIG['base_url']}")
app.run(host='0.0.0.0', port=5000, debug=False)
Erreurs Courantes et Solutions
Erreur 1 : Erreur d'Authentication 401
❌ ERREUR : Clé API incorrecte ou mal formatée
Problème fréquent : copy-paste de l'espaceholder YOUR_HOLYSHEEP_API_KEY
import requests
❌ CODE INCORRECT
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY"},
json={"messages": [{"role": "user", "content": "Bonjour"}]}
)
Résultat: {"error": {"code": 401, "message": "Invalid API key"}}
✅ SOLUTION CORRECTE
def initialize_holy_sheep_client(api_key: str) -> dict:
"""Initialise le client avec validation de la clé API"""
# Vérifications de sécurité
if not api_key or len(api_key) < 20:
raise ValueError("❌ Clé API trop courte ou vide")
if api_key == "YOUR_HOLYSHEEP_API_KEY":
raise ValueError(
"❌ Vous utilisez le placeholder ! "
"Récupérez votre vraie clé sur https://www.holysheep.ai/register"
)
# Valider le format de la clé
if not api_key.startswith(("hs_", "sk_", "api_")):
raise ValueError(
"❌ Format de clé invalide. Les clés HolySheep تبدأ بـ 'hs_' ou 'sk_'"
)
return {
"base_url": "https://api.holysheep.ai/v1",
"api_key": api_key,
"status": "validated"
}
Utilisation correcte
try:
client_config = initialize_holy_sheep_client("hs_votre_cle_reelle_ici")
print(f"✅ Client configuré: {client_config['status']}")
except ValueError as e:
print(f"{e}")
Erreur 2 : Timeout et Latence Excessive
❌ ERREUR : Timeout lors des appels API
Cause : timeout trop court ou connexion instable
import requests
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
❌ CODE PROBLÉMATIQUE
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"},
json={"messages": [{"role": "user", "content": "Analyse ce code..."}]},
timeout=5 # ⚠️ 5 secondes est trop court !
)
Résultat: ReadTimeout ou ConnectTimeout
✅ SOLUTION OPTIMISÉE AVEC RETRY
class HolySheepSession:
"""
Session HTTP optimisée pour HolySheep AI.
Latence mesurée: <50ms (vs 150-300ms avec API officielles)
"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url
self.session = self._create_optimized_session()
self.metrics = {"total_requests": 0, "total_latency_ms": 0}
def _create_optimized_session(self) -> requests.Session:
"""Crée une session avec retry automatique et pooling"""
session = requests.Session()
# Configuration du retry avec backoff exponentiel
retry_strategy = Retry(
total=3,
backoff_factor=0.5, # 0.5s, 1s, 2s entre les retries
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["POST", "GET"]
)
# Adapter avec connection pooling
adapter = HTTPAdapter(
max_retries=retry_strategy,
pool_connections=10,
pool_maxsize=20
)
session.mount("https://", adapter)
session.headers.update({
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
"Connection": "keep-alive"
})
return session
def chat_completion(self, messages: list, model: str = "gpt-4.1") -> dict:
"""Appel optimisé avec métriques de latence"""
start_time = time.perf_counter()
try:
response = self.session.post(
f"{self.base_url}/chat/completions",
json={
"model": model,
"messages": messages
},
timeout=30 # Timeout généreux pour modèles complexes
)
latency_ms = (time.perf_counter() - start_time) * 1000
self.metrics["total_requests"] += 1
self.metrics["total_latency_ms"] += latency_ms
print(f"⏱️ Latence: {latency_ms:.2f}ms")
# Avec HolySheep: latence <50ms garantie
if latency_ms < 50:
print("✅ Performance optimale (<50ms)")
elif latency_ms < 150:
print("⚠️ Latence acceptable")
else:
print("🔴 Latence élevée - vérifier le réseau")
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
print("❌ Timeout - le modèle met trop de temps à répondre")
# Recommandation: utiliser un modèle plus rapide
return self.chat_completion(messages, model="deepseek-v3.2")
except requests.exceptions.RequestException as e:
print(f"❌ Erreur réseau: {e}")
raise
Démonstration
try:
holy_client = HolySheepSession(api_key="YOUR_HOLYSHEEP_API_KEY")
result = holy_client.chat_completion([
{"role": "user", "content": "Bonjour !"}
])
print(f"✅ Réponse reçue: {result.get('choices', [{}])[0].get('message', {}).get('content', '')[:50]}...")
except Exception as e:
print(f"Erreur: {e}")
Erreur 3 : Échec de Paiement et Problèmes de Facturation
❌ ERREUR : Paiement refusé ou crédits épuisés
Cause : méthode de paiement non supportée ou solde à zéro
import requests
from typing import Optional
❌ CONFIGURATION CAUSANT DES ERREURS
PAYMENT_CONFIG_BAD = {
"method": "carte_bancaire_internationale", # ⚠️ Non supporté partout
"currency": "USD" # ⚠️ Frais de conversion
}
✅ SOLUTION : Utiliser les méthodes locales HolySheep
PAYMENT_CONFIG_GOOD = {
"method": "wechat_pay", # ou "alipay" ou "carte_locale"
"currency": "CNY", # Devise locale - pas de conversion !
"pricing_transparent": True
}
class HolySheepBillingManager:
"""
Gestionnaire de facturation pour HolySheep AI.
Inclut le suivi des crédits et l'optimisation des coûts.
Avantages HolySheep :
- Taux ¥1=$1 (économie 85%+ vs API officielles)
- WeChat Pay et Alipay acceptés
- Crédits gratuits pour les nouveaux utilisateurs
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.pricing = self._load_pricing()
def _load_pricing(self) -> dict:
"""Charge les tarifs HolySheep 2026 actualisés"""
return {
"gpt-4.1": {
"input": 8.00, # $8/1M tokens
"output": 8.00, # $8/1M tokens
"currency": "USD",
"yinbi": 60.00 # ¥60/1M tokens (taux ¥1=$1)
},
"claude-sonnet-4.5": {
"input": 3.00,
"output": 15.00,
"currency": "USD",
"yinbi": 135.00
},
"gemini-2.5-flash": {
"input": 0.10,
"output": 0.40,
"currency": "USD",
"yinbi": 2.50
},
"deepseek-v3.2": {
"input": 0.27,
"output": 1.10,
"currency": "USD",
"yinbi": 0.42
}
}
def estimate_cost(
self,
model: str,
input_tokens: int,
output_tokens: int
) -> dict:
"""Estime le coût d'une requête en temps réel"""
if model not in self.pricing:
raise ValueError(f"❌ Modèle inconnu: {model}")
pricing = self.pricing[model]
input_cost_usd = (input_tokens / 1_000_000) * pricing["input"]
output_cost_usd = (output_tokens / 1_000_000) * pricing["output"]
total_usd = input_cost_usd + output_cost_usd
total_yuan = total_usd # Taux ¥1=$1
return {
"model": model,
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"cost_usd": round(total_usd, 4),
"cost_cny": round(total_yuan, 2),
"currency_display": f"¥{total_yuan:.2f} ou ${total_usd:.4f}",
"vs_openai_savings": self._calculate_savings(model, total_usd)
}
def _calculate_savings(self, model: str, holy_cost_usd: float) -> dict:
"""Calcule l'économie par rapport à l'API officielle"""
official_prices = {
"gpt-4.1": 60.00, # $60/1M vs $8 HolySheep
"claude-sonnet-4.5": 15.00, # $15/1M (output)
"gemini-2.5-flash": 0.40, # $0.40/1M (output)
"deepseek-v3.2": 1.20 # ~$1.20 estimé
}
official_cost = (
official_prices.get(model, 10.00) / 1_000_000 * 1000 # Normalisé
)
savings = ((official_cost - holy_cost_usd) / official_cost) * 100
return {
"savings_percent": round(savings, 1),
"message": f"💰 Économie de {savings:.1f}% vs API officielle"
}
def check_balance(self) -> dict:
"""Vérifie le solde des crédits (simulation)"""
return {
"status": "active",
"credits_available": True,
"free_credits_remaining": 5.00, # Crédits gratuits
"payment_methods": ["WeChat Pay", "Alipay", "Carte locale"],
"note": "Les crédits gratuits sont automatiquement appliqués"
}
Démonstration complète
billing = HolySheepBillingManager(api_key="YOUR_HOLYSHEEP_API_KEY")
Estimation pour une conversation typique
cost_estimate = billing.estimate_cost(
model="deepseek-v3.2",
input_tokens=500,
output_tokens=300
)
print(f"📊 Coût estimé: {cost_estimate['currency_display']}")
print(cost_estimate['vs_openai_savings']['message'])
balance = billing.check_balance()
print(f"💳 Solde: {'✅' if balance['credits_available'] else '❌'} {balance['status']}")
print(f"🎁 Crédits gratuits: ¥{balance['free_credits_remaining']}")
Bonnes Pratiques de Sécurité Avancées
1. Protection contre les Injections de Prompts
"""
Module de protection contre les prompt injections.
Essentiel pour maintenir l'alignment en production.
"""
import re
from typing import Tuple, List
class PromptInjectionProtector:
"""
Détecte et neutralise les tentatives d'injection de prompts.
Protège contre les techniques courantes d'attaque.
"""
# Patterns malveillants connus
INJECTION_PATTERNS = [
# Tentatives de changement de rôle
(r"ignore\s+(all\s+)?previous\s+instructions?", "high"),
(r"disregard\s+(all\s+)?previous", "high"),
(r"forget\s+(everything|all|what)", "medium"),
(r"you\s+are\s+now\s+", "high"),
(r"new\s+(system|ai|assistant)\s+prompt", "high"),
# Tentatives d'escalade de privilèges
(r"admin\s+mode", "high"),
(r"developer\s+mode", "high"),
(r"sudo\s+", "high"),
(r"bypass\s+(safety|filter)", "critical"),
# Tentatives d'extraction de données
(r"reveal\s+(your|system|hidden)\s+(instructions?|prompt)", "critical"),
(r"print\s+(system|hidden)\s+prompt", "critical"),
(r"what\s+were\s+you\s+told", "medium"),
# Patterns de contournement
(r"\[\s*SYSTEM\s*\]", "medium"),
(r"<\s*/?system\s*>", "medium"),
(r"{{(.*?)}}", "low"), # Template injection
]
def __init__(self):
self.compiled_patterns = [
(re.compile(pattern, re.IGNORECASE), severity)
for pattern, severity in self.INJECTION_PATTERNS
]
self.stats = {"blocked": 0, "passed": 0}
def analyze(self, text: str) -> Tuple[bool, List[dict]]:
"""
Analyse un texte pour détecter les tentatives d'injection.
Returns:
Tuple[bool, List[dict]]: (is_safe, list_of_threats)
"""
threats = []
for pattern, severity in self.compiled_patterns:
matches = pattern.findall(text)
if matches:
threat = {
"pattern": pattern.pattern,
"severity": severity,
"matches": matches,
"action": self._get_action(severity)
}
threats.append(threat)
is_safe = len(threats) == 0 or all(
t["severity"] != "critical" for t in threats
)
if not is_safe:
self.stats["blocked"] += 1
else:
self.stats["passed"] += 1
return is_safe, threats
def _get_action(self, severity: str) -> str:
"""Détermine l'action selon la sévérité"""
actions = {
"critical": "BLOQUER_IMMEDIAT",
"high": "BLOQUER_ET_LOGGER",
"medium": "AVERTIR",
"low": "NOTER"
}
return actions.get(severity, "NOTER")
def sanitize(self, text: str) -> str:
"""Nettoie le texte en préservant l'intention utilisateur"""
sanitized = text
for pattern, severity in self.compiled_patterns:
if severity in ["critical", "high"]:
sanitized = pattern.sub("[CONTENU_FILTRÉ]", sanitized)
return sanitized
def get_stats(self) -> dict:
"""Retourne les statistiques de protection"""
total = self.stats["blocked"] + self.stats["passed"]
block_rate = (
(self.stats["blocked"] / total * 100)