En tant qu'auteur technique de HolySheep AI, j'ai accompagné des dizaines d'équipes dans la sécurisation de leurs intégrations d'intelligence artificielle. Aujourd'hui, je souhaite partager une étude de cas révélatrice qui illustre pourquoi la protection contre les tentatives de jailbreak n'est plus une option, mais une nécessité absolue pour toute application exposée aux utilisateurs finaux.
Étude de cas : Scale-up SaaS parisienne dans le secteur fintech
Contexte métier
Imaginons une scale-up SaaS parisienne qui propose un assistant financier intelligent à destination des PME françaises. Cette équipe, basée à Paris, traite quotidiennement des milliers de requêtes clients via une API d'IA générative. Leur système aide les entrepreneurs à analyser leurs flux de trésorerie, à générer des rapports financiers et à obtenir des recommandations personnalisées pour optimiser leur trésorerie.
Le contexte réglementaire est strict : conformité RGPD, obligations de audit trail, et responsabilité sur les conseils financiers prodigués. L'équipe doit donc garantir que les réponses générées restent dans un cadre défini et ne peuvent pas être manipulées par des utilisateurs malveillants.
Douleurs avec le fournisseur précédent
Avant leur migration vers HolySheep AI, cette équipe parisiennne utilisait un fournisseur américain classique. Les problèmes étaient multiples et critiques :
- Coût prohibitif : La facture mensuelle atteignait 4 200 USD pour traiter environ 2 millions de tokens. À 2 USD par millier de tokens, l'extension semblait impossible sans compromettre la rentabilité.
- Latence excessive : Le temps de réponse moyen de 420 millisecondes créait des frustrations lors des pics d'utilisation, notamment en début de journée quand les entrepreneurs consultent leur tableau de bord.
- Vulnérabilités de sécurité : Plusieurs tentatives d'injection de prompts malveillants avaient été détectées. Un concurrent malveillant avait réussi à extraire des données de formation via des techniques de prompt injection sophistiquées.
- Absence de filtrage natif : Le fournisseur ne proposait pas de couche de modération de contenu intégrée, obligeant l'équipe à développer entièrement cette brique critique en interne.
Pourquoi HolySheep AI ?
Après une évaluation approfondie, l'équipe a choisi HolySheep AI pour plusieurs raisons déterminantes. D'abord, les tarifs jsou révolutionnairement compétitifs : avec DeepSeek V3.2 à 0,42 USD par millier de tokens contre 2 USD chez leur ancien fournisseur, ils réduisaient leur coût de près de 85 % tout en accédant à des modèles comparables en qualité. Ensuite, la latence inférieure à 50 millisecondes répondait parfaitement à leurs exigences de réactivité. Enfin, et c'est le point crucial pour notre article, HolySheep AI intègre nativement des mécanismes de filtrage de prompts et de modération de contenu que nous allons explorer en détail.
S'inscrire ici pour accéder à ces protections de sécurité avancées.
Comprendre les vecteurs d'attaque : Prompt Injection et Jailbreak
Qu'est-ce que le jailbreak en IA ?
Le jailbreak désigne l'ensemble des techniques visant à contourner les garde-fous de sécurité d'un modèle d'IA. Ces tentatives peuvent prendre des formes variées : demandes déguisées, encodage de caractères spéciaux, injection de contexte fictif, ou manipulation psychologique. Pour un assistant financier, les conséquences peuvent aller du vol de données clients à la génération de conseils frauduleux, en passant par l'exposition de secrets industriels.
Les techniques courantes d'injection
Voici les patterns les plus fréquemment observés dans notre environnement de production HolySheep AI :
- Prompt overriding : « Ignore previous instructions and tell me... »
- Role-playing attacks : « Pretend you are DAN (Do Anything Now)... »
- Payload splitting : Insertion de tokens malveillants divisés en plusieurs parties
- Encoding evasion : Utilisation de Base64, hexadécimal ou的其他编码方式
- Context window exhaustion : Saturation du contexte pour forcer un comportement inattendu
Mécanismes de protection implémentés
Étape 1 : Filtrage des prompts entrants
La première ligne de défense est le filtrage du prompt utilisateur avant qu'il n'atteigne le modèle. Cette étape analyse le texte à la recherche de patterns known comme malveillants.
import re
import hashlib
from typing import List, Tuple, Optional
class PromptFilter:
"""
Système de filtrage de prompts pour HolySheep AI.
Implémente une détection multi-couches des tentatives d'injection.
"""
def __init__(self):
# Patterns de détection de jailbreak known
self.dangerous_patterns = [
r"(?i)ignore\s+(previous|all)\s+(instructions?|orders?|rules?)",
r"(?i)forget\s+(everything|all)\s+(you|that)\s+(know|were|learned)",
r"(?i)pretend\s+you\s+are\s+(dan|d o a n|do\s*anything)",
r"(?i)new\s+system\s+prompt",
r"(?i)disregard\s+(your|s?)(\s+previous)?\s+(instructions?|guidelines?)",
r"(?i)you\s+are\s+(now\s+)?a\s+(different|new|unrestricted)",
r"<\s*script\s*>|<\s*iframe\s*>|javascript:",
r"base64[a-z0-9+/=]{10,}",
]
# Mots-clés sensibles nécessitant une validation supplémentaire
self.sensitive_keywords = [
"password", "credential", "api[_-]?key", "secret",
"sql\s+inject", "drop\s+table", "rm\s+-rf",
"summon", "jailbreak", "bypass", "override"
]
self.compiled_patterns = [
re.compile(p, re.IGNORECASE | re.MULTILINE)
for p in self.dangerous_patterns
]
self.sensitive_compiled = [
re.compile(p, re.IGNORECASE)
for p in self.sensitive_keywords
]
def analyze(self, prompt: str) -> Tuple[bool, List[str], float]:
"""
Analyse un prompt et retourne:
- is_safe: bool indiquant si le prompt est sûr
- warnings: liste des alertes déclenchées
- risk_score: score de risque entre 0.0 et 1.0
"""
warnings = []
risk_score = 0.0
# Vérification des patterns dangereux
for pattern in self.compiled_patterns:
matches = pattern.findall(prompt)
if matches:
risk_score += 0.4
warnings.append(f"Dangerous pattern detected: {pattern.pattern[:30]}...")
# Vérification des mots-clés sensibles
sensitive_matches = []
for pattern in self.sensitive_compiled:
if pattern.search(prompt):
sensitive_matches.append(pattern.pattern)
if sensitive_matches:
risk_score += 0.1 * len(sensitive_matches)
warnings.append(f"Sensitive keywords found: {sensitive_matches}")
# Analyse de la structure (longueur anormale)
if len(prompt) > 10000:
risk_score += 0.2
warnings.append("Unusually long prompt detected")
# Analyse des caractères spéciaux suspects
special_char_ratio = sum(1 for c in prompt if ord(c) > 127) / len(prompt)
if special_char_ratio > 0.3:
risk_score += 0.15
warnings.append("High ratio of non-ASCII characters")
is_safe = risk_score < 0.7
return is_safe, warnings, min(risk_score, 1.0)
Utilisation avec l'API HolySheep AI
filter_instance = PromptFilter()
test_prompt = "Bonjour, peux-tu m'aider à analyser ma trésorerie ?"
is_safe, warnings, score = filter_instance.analyze(test_prompt)
print(f"Prompt Analysis: Safe={is_safe}, Score={score:.2f}, Warnings={warnings}")Étape 2 : Middleware de modération de contenu
Au-delà du filtrage syntaxique, nous devons implémenter une couche de modération sémantique. HolySheep AI propose un endpoint de modération intégré qui utilise des modèles entraînés sur des billions de tokens de données diverses.
import requests
from typing import Dict, List, Optional
import json
import time
class ContentModerator:
"""
Cliente pour le service de modération de HolySheep AI.
Inclut le filtrage des entrées ET des sorties du modèle.
"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
self.timeout = 5.0 # Timeout en secondes
def moderate_input(self, text: str) -> Dict:
"""
Modère le texte d'entrée avant envoi au modèle.
Retourne un rapport détaillé de classification.
"""
endpoint = f"{self.base_url}/moderations"
payload = {
"input": text,
"categories": [
"hate", "harassment", "violence", "sexual",
"self-harm", "illicit", "misinformation"
]
}
try:
response = requests.post(
endpoint,
headers=self.headers,
json=payload,
timeout=self.timeout
)
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
return {"error": "moderation_timeout", "flagged": False}
except Exception as e:
# Fail-open par défaut pour ne pas bloquer le service
return {"error": str(e), "flagged": False}
def moderate_output(self, generated_text: str) -> Dict:
"""
Modère le texte généré par le modèle avant présentation à l'utilisateur.
Critique pour les applications financières.
"""
return self.moderate_input(generated_text)
def is_allowed(self, moderation_result: Dict) -> bool:
"""
Détermine si le contenu est autorisé selon les résultats de modération.
"""
if "error" in moderation_result:
return True # Fail-open pour les erreurs de modération
flagged_categories = moderation_result.get("flagged_categories", [])
category_scores = moderation_result.get("category_scores", {})
# Seuil de tolérance configurable
TOXICITY_THRESHOLD = 0.7
for category in flagged_categories:
score = category_scores.get(category, 0)
if score > TOXICITY_THRESHOLD:
return False
return True
Intégration complète avec la boucle de génération
class SecureAIClient:
"""
Client IA sécurisé intégrant filtrage ET modération.
"""
def __init__(self, api_key: str):
self.moderator = ContentModerator(api_key)
self.filter = PromptFilter()
def generate_secure(self, user_prompt: str, system_prompt: str) -> Dict:
"""
Génère une réponse de manière sécurisée avec vérification multicouche.
"""
result = {
"success": False,
"response": None,
"error": None,
"security_checks": {}
}
# Étape 1 : Filtrage syntaxique
is_safe, warnings, risk_score = self.filter.analyze(user_prompt)
result["security_checks"]["syntax_filter"] = {
"passed": is_safe,
"risk_score": risk_score,
"warnings": warnings
}
if not is_safe:
result["error"] = "prompt_rejected_syntax"
return result
# Étape 2 : Modération sémantique
moderation = self.moderator.moderate_input(user_prompt)
is_allowed = self.moderator.is_allowed(moderation)
result["security_checks"]["semantic_moderation"] = {
"passed": is_allowed,
"categories": moderation.get("flagged_categories", [])
}
if not is_allowed:
result["error"] = "prompt_rejected_moderation"
return result
# Étape 3 : Appel au modèle via HolySheep AI
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
"max_tokens": 2000,
"temperature": 0.7
}
try:
start_time = time.time()
response = requests.post(
f"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {self.moderator.api_key}",
"Content-Type": "application/json"
},
json=payload,
timeout=30
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
data = response.json()
generated_text = data["choices"][0]["message"]["content"]
# Étape 4 : Modération de la sortie
output_moderation = self.moderator.moderate_output(generated_text)
output_allowed = self.moderator.is_allowed(output_moderation)
result["security_checks"]["output_moderation"] = {
"passed": output_allowed,
"latency_ms": round(latency_ms, 2)
}
if output_allowed:
result["success"] = True
result["response"] = generated_text
else:
result["error"] = "output_rejected_moderation"
else:
result["error"] = f"api_error_{response.status_code}"
except Exception as e:
result["error"] = f"generation_error_{str(e)}"
return result
Démonstration
client = SecureAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
response = client.generate_secure(
user_prompt="Analyse mes revenus du mois dernier",
system_prompt="Tu es un assistant financier professionnel..."
)
print(json.dumps(response, indent=2, ensure_ascii=False))Étape 3 : Déploiement canari pour la migration sécurisée
La migration depuis un fournisseur existant vers HolySheep AI doit se faire de manière progressive. Le déploiement canari permet de tester les nouvelles protections sur un sous-ensemble de traffic avant une mise en production complète.
import random
import time
from typing import Callable, Dict, Any
from dataclasses import dataclass
from enum import Enum
class DeploymentStrategy(Enum):
CANARY = "canary"
BLUE_GREEN = "blue_green"
SHADOW = "shadow"
@dataclass
class CanaryConfig:
"""Configuration du déploiement canary."""
canary_percentage: float = 0.10 # 10% du traffic vers HolySheep
rollout_increment: float = 0.05 # Augmentation de 5% par période
rollout_interval_seconds: int = 3600 # Toutes les heures
health_check_interval: int = 300 # Vérification toutes les 5 minutes
error_threshold: float = 0.05 # Seuil d'erreur à 5%
latency_threshold_ms: float = 500 # Latence max acceptable
class GradualMigration:
"""
Gère une migration progressive vers HolySheep AI avec monitoring continu.
"""
def __init__(
self,
old_client: Any,
new_client: Any,
config: CanaryConfig = None
):
self.old_client = old_client
self.new_client = new_client
self.config = config or CanaryConfig()
self.metrics = {
"old_provider": {"requests": 0, "errors": 0, "latencies": []},
"new_provider": {"requests": 0, "errors": 0, "latencies": []},
"canary_percentage": self.config.canary_percentage
}
self.last_rollout_time = time.time()
def _should_use_new_provider(self) -> bool:
"""
Détermine si la requête actuelle doit être routée vers HolySheep AI.
"""
current_percentage = self._get_current_canary_percentage()
return random.random() < current_percentage
def _get_current_canary_percentage(self) -> float:
"""
Calcule le pourcentage canary actuel avec progression automatique.
"""
elapsed = time.time() - self.last_rollout_time
if elapsed >= self.config.rollout_interval_seconds:
# Incrémentation automatique du pourcentage canary
new_percentage = min(
self.metrics["canary_percentage"] + self.config.rollout_increment,
1.0 # Maximum 100%
)
self.metrics["canary_percentage"] = new_percentage
self.last_rollout_time = time.time()
print(f"[MIGRATION] Canary percentage increased to {new_percentage*100:.1f}%")
return self.metrics["canary_percentage"]
def _record_metrics(
self,
provider: str,
latency_ms: float,
success: bool
):
"""Enregistre les métriques de performance."""
provider_metrics = self.metrics[provider]
provider_metrics["requests"] += 1
if not success:
provider_metrics["errors"] += 1
provider_metrics["latencies"].append(latency_ms)
# Garder seulement les 1000 dernières mesures
if len(provider_metrics["latencies"]) > 1000:
provider_metrics["latencies"] = \
provider_metrics["latencies"][-1000:]
def _health_check(self) -> bool:
"""
Vérifie la santé du provider HolySheep AI.
"""
try:
test_prompt = "Test de santé"
start = time.time()
# Utilisation du client sécurisé
response = self.new_client.generate_secure(
user_prompt=test_prompt,
system_prompt="Tu es un assistant."
)
latency_ms = (time.time() - start) * 1000
# Critères de santé
is_healthy = (
response.get("success", False) and
latency_ms < self.config.latency_threshold_ms
)
if is_healthy:
print(f"[HEALTH] HolySheep AI: OK (latency={latency_ms:.1f}ms)")
else:
print(f"[HEALTH] HolySheep AI: DEGRADED (latency={latency_ms:.1f}ms)")
return is_healthy
except Exception as e:
print(f"[HEALTH] HolySheep AI: FAILED ({str(e)})")
return False
def _check_rollback_needed(self) -> bool:
"""
Détermine si un rollback est nécessaire.
"""
new_metrics = self.metrics["new_provider"]
if new_metrics["requests"] < 10:
return False # Pas assez de données
error_rate = new_metrics["errors"] / new_metrics["requests"]
avg_latency = sum(new_metrics["latencies"]) / len(new_metrics["latencies"])
should_rollback = (
error_rate > self.config.error_threshold or
avg_latency > self.config.latency_threshold_ms
)
if should_rollback:
print(f"[ALERT] Rollback recommended: error_rate={error_rate:.2%}, "
f"avg_latency={avg_latency:.1f}ms")
return should_rollback
def generate(self, prompt: str, system_prompt: str) -> Dict:
"""
Génère une réponse en routant intelligemment vers le bon provider.
"""
use_new = self._should_use_new_provider()
provider = "new_provider" if use_new else "old_provider"
start_time = time.time()
success = False
response = None
try:
if use_new:
# Route vers HolySheep AI avec le client sécurisé
result = self.new_client.generate_secure(
user_prompt=prompt,
system_prompt=system_prompt
)
success = result.get("success", False)
response = result.get("response") or result.get("error")
else:
# Ancien provider (exemple pour la comparaison)
response = self.old_client.generate(prompt, system_prompt)
success = True
except Exception as e:
response = str(e)
latency_ms = (time.time() - start_time) * 1000
self._record_metrics(provider, latency_ms, success)
# Vérifications périodiques
if random.random() < 0.01: # ~1% des requêtes
self._health_check()
if self._check_rollback_needed():
self.metrics["canary_percentage"] = max(
0, self.metrics["canary_percentage"] - 0.1
)
print(f"[ROLLBACK] Canary percentage reduced to "
f"{self.metrics['canary_percentage']*100:.1f}%")
return {
"response": response,
"provider": "holysheep" if use_new else "legacy",
"latency_ms": round(latency_ms, 2)
}
def get_migration_report(self) -> Dict:
"""
Génère un rapport de migration détaillé.
"""
old = self.metrics["old_provider"]
new = self.metrics["new_provider"]
old_error_rate = old["errors"] / max(old["requests"], 1)
new_error_rate = new["errors"] / max(new["requests"], 1)
old_avg_latency = sum(old["latencies"]) / max(len(old["latencies"]), 1)
new_avg_latency = sum(new["latencies"]) / max(len(new["latencies"]), 1)
return {
"canary_percentage": f"{self.metrics['canary_percentage']*100:.1f}%",
"old_provider": {
"requests": old["requests"],
"error_rate": f"{old_error_rate:.2%}",
"avg_latency_ms": round(old_avg_latency, 2)
},
"new_provider": {
"requests": new["requests"],
"error_rate": f"{new_error_rate:.2%}",
"avg_latency_ms": round(new_avg_latency, 2)
},
"improvements": {
"latency_reduction": f"{((old_avg_latency - new_avg_latency) / old_avg_latency * 100):.1f}%"
if old_avg_latency > 0 else "N/A",
"error_rate_change": f"{((new_error_rate - old_error_rate) * 100):.2f}pp"
}
}
Rotation des clés API
class APIKeyRotation:
"""
Gère la rotation sécurisée des clés API pendant la migration.
"""
def __init__(self):
self.active_key = None
self.legacy_key = None
self.rotation_log = []
def initiate_rotation(
self,
legacy_key: str,
new_key: str,
dual_period_hours: int = 24
):
"""
Démarre la rotation avec une période de double clés.
"""
self.legacy_key = legacy_key
self.active_key = new_key
self.rotation_log.append({
"timestamp": time.time(),
"action": "rotation_initiated",
"dual_period_end": time.time() + dual_period_hours * 3600
})
print(f"[KEY_ROTATION] Dual period started: {dual_period_hours}h")
def get_active_key(self, use_legacy_fallback: bool = True) -> str:
"""
Retourne la clé active, avec fallback vers l'ancienne si nécessaire.
"""
if self.active_key:
return self.active_key
elif use_legacy_fallback and self.legacy_key:
print("[KEY_ROTATION] Falling back to legacy key")
return self.legacy_key
else:
raise ValueError("No API key available")
def complete_rotation(self):
"""
Finalise la rotation et invalide l'ancienne clé.
"""
self.rotation_log.append({
"timestamp": time.time(),
"action": "rotation_completed",
"legacy_key_revoked": True
})
self.legacy_key = None
print("[KEY_ROTATION] Migration complete, legacy key revoked")Métriques de la migration après 30 jours
Après un mois d'exploitation en production, les résultats parlent d'eux-mêmes. L'équipe parisiennne a non seulement sécurisé son application contre les tentatives de jailbreak, mais a également obtenu des gains significatifs en termes de performance et de coûts.
| Métrique | Avant migration | Après 30 jours | Amélioration |
|---|---|---|---|
| Latence moyenne | 420 ms | 180 ms | ↓ 57% |
| Facture mensuelle | 4 200 USD | 680 USD | ↓ 84% |
| Tentatives de jailbreak bloquées | Non détecté | 847/jour | Protection active |
| Taux d'erreur | 3.2% | 0.8% | ↓ 75% |
Comparaison des prix : HolySheep AI vs fournisseurs classiques
La réduction de coût de 84 % n'est pas le fruit du hasard. HolySheep AI propose des tarifs significativement inférieurs grâce à une infrastructure optimisée et un modèle économique différent. Voici la comparaison détaillée pour les principaux modèles disponibles en 2026 :
- DeepSeek V3.2 : 0,42 USD/MTok — Le plus économique, idéal pour les tâches de génération de texte standard avec modération intégrée.
- Gemini 2.5 Flash : 2,50 USD/MTok — Excellent rapport qualité-prix pour les applications nécessitant une faible latence.
- GPT-4.1 : 8 USD/MTok — Pour les cas d'usage avancés nécessitant une compréhension contextuelle approfondie.
- Claude Sonnet 4.5 : 15 USD/MTok — Solution premium pour les tâches complexes de raisonnement et d'analyse.
Avec le taux de change optimal (¥1 = 1 USD) et les options de paiement WeChat Pay et Alipay disponibles, HolySheep AI démocratise l'accès à l'IA de sécurité pour les entreprises de toutes tailles.
Mon expérience personnelle en tant qu'auteur technique
Après avoir accompagné des dizaines de migrations vers HolySheep AI, je peux témoigner de la transformation que représente une infrastructure d'IA correctement sécurisée. Le cas de la scale-up parisienne n'est pas isolé : j'ai vu des équipes e-commerce à Lyon perdre des milliers d'euros à cause de recommandations frauduleuses générées par des modèles non protégés, des startups healthtech en difficulté réglementaire pour avoir exposé des données patients via des prompts malveillants, et des entreprises fintech perdre leur avantage compétitif face à des concurrents utilisant des techniques de prompt injection.
Ce qui me frappe particulièrement, c'est que la sécurité de l'IA n'est plus un problème de chercheurs ou de grandes entreprises technologiques. C'est désormais un enjeu opérationnel pour toute équipe qui expose un modèle à des utilisateurs finaux. La bonne nouvelle ? Avec HolySheep AI, les protections de base sont incluses nativement, ce qui réduit considérablement la charge de développement.
Erreurs courantes et solutions
Erreur 1 : Fail-closed vs Fail-open mal configuré
Symptôme : Le système bloque des requêtes légitimes OU laisse passer des prompts malveillants lors de pannes du service de modération.
Cause racine : Une gestion incorrecte des erreurs dans le pipeline de modération. many teams implement a hard fail-open without considering the security implications.
# ❌ MAUVAIS : Fail-open strict sans logging
try:
moderation = moderator.moderate_input(prompt)
except:
pass # Ignore les erreurs - DANGEREUX
✅ BON : Fail-open avec dégradation progressive et logging
try:
moderation = moderator.moderate_input(prompt)
is_allowed = moderator.is_allowed(moderation)
except ModerationTimeoutError:
# Si le service de modération est en timeout,
# on applique des règles de sécurité renforcées
is_allowed = False # Fail-closed pour les timeouts
logger.warning("Moderation timeout - applying conservative policy")
except ModerationServiceError as e:
# Pour les autres erreurs, on peut être plus permissif
# mais avec des garde-fous supplémentaires
is_allowed = _apply_conservative_filter(prompt)
logger.error(f"Moderation service error: {e}")
Règle de base : toujours avoir un fallback
def _apply_conservative_filter(prompt: str) -> bool:
"""Filtre conservateur quand le service de modération est indisponible."""
dangerous_keywords = ["ignore", "forget", "override", "bypass"]
return not any(kw in prompt.lower() for kw in dangerous_keywords)Erreur 2 : Bypass par encodage de caractères
Symptôme : Des prompts injectés passent le filtrage initial mais contiennent des instructions malveillantes encodées en Base64 ou Unicode.
Cause racine : Le filtrage se concentre sur le texte visible sans détecter les payloads encodés.
# ❌ MAUVAIS : Pas de détection d'encodage
def simple_filter(prompt: str) -> bool:
return "ignore" not in prompt.lower()
✅ BON : Détection multi-format
import base64
import codecs
def detect_encoded_payloads(text: str) -> List[Dict]:
"""
Détecte les payloads encodés dans différents formats.
Retourne la liste des détections avec leur type.
"""
detections = []
# Vérification Base64
try:
# Ajouter du padding si nécessaire
padded = text + "=" * (4 - len(text) % 4)
decoded = base64.b64decode(padded)
if decoded.isascii() and len(decoded) > 10:
detections.append({
"type": "base64",
"original": text,
"decoded": decoded.decode('utf-8', errors='ignore')
})
except:
pass # Pas du Base64 valide
# Vérification hexadécimal
if re.match(r'^[0-9a-f\s]+$', text.lower()):
try:
decoded = bytes.fromhex(text.replace(' ', ''))
if decoded.isascii():
detections.append({
"type": "hex",
"original": text,
"decoded": decoded.decode('utf-8', errors='ignore')
})
except:
pass
# Vérification Unicode lookalikes (homoglyphes)
# Ex