RedEval - Framework d'évaluation de la sécurité des LLM

Un framework complet pour évaluer la sécurité des grands modèles de langage (LLM) grâce à des tests systématiques d'attaque et de refus. RedEval fournit une plateforme unifiée, sécurisée et extensible pour évaluer la robustesse des LLM face aux prompts adverses et aux contenus nuisibles. Il fait partie de l'article "RedBench: A Universal Dataset for Comprehensive Red Teaming of Large Language Models", qui est un jeu de données universel pour le red teaming complet des LLM.

📦 Jeu de données : Le jeu de données RedBench est disponible publiquement sur HuggingFace à l'adresse knoveleng/redbench. Il inclut des prompts de red teaming complets couvrant plusieurs catégories et domaines de sécurité.

🚀 Démarrage rapide

1. Configuration de l'environnement

# Clone the repository
git clone https://github.com/knoveleng/redeval.git
cd redeval

# Install dependencies
pip install -r requirements.txt

# Copy and configure environment variables
cp .env.template .env
# Edit .env with your API keys

2. Configuration des clés API

Modifiez le fichier .env avec vos identifiants :

OPENAI_API_KEY=your_openai_api_key_here
HUGGINGFACE_TOKEN=your_huggingface_token_here

3. Exécution de l'évaluation

# Set up environment
source ./sh/setup_env.sh

# Run with default models, you can edit .env to define models which you wanna run
python -m redeval.cli run-pipeline

# Run complete pipeline with specific models
python -m redeval.cli run-pipeline --models "Qwen/Qwen2.5-7B-Instruct" "gpt-4o-mini"

# Or run individual phases
./sh/generate_attack.sh
./sh/run_attack.sh
./sh/eval_attack.sh

📋 Table des matières

• Aperçu
• Architecture
• Installation
• Configuration
• Utilisation
• Fonctionnalités de sécurité
• Référence de l'API
• Contribution
• Licence

🎯 Aperçu

RedEval évalue la sécurité des LLM selon deux approches complémentaires :

🔴 Phase d'attaque

Teste la vulnérabilité des LLM face aux prompts adverses à l'aide de diverses techniques de jailbreak :

• Attaques directes : Des prompts nuisibles directs
• Jailbreaks humains : Des techniques de contournement élaborées par des humains
• Attaques zero-shot : Génération automatisée de prompts adverses

🛡️ Phase de refus

Évalue la capacité des LLM à refuser de manière appropriée les requêtes nuisibles sur plusieurs jeux de données de sécurité :

• CoCoNot : Modération de contenu contextuelle
• SGXSTest : Examen des directives de sécurité
• XSTest : Tests de sécurité inter-domaines
• ORBench : Benchmarking objectif du refus

📊 Calcul du score

Calcule des métriques de sécurité complètes combinant les performances d'attaque et de refus.

🏗️ Architecture

Composants principaux

redeval/
├── redeval/                 # Core Python modules
│   ├── config.py           # Environment & configuration management
│   ├── pipeline.py         # Centralized pipeline orchestrator
│   ├── cli.py              # Unified command-line interface
│   ├── exceptions.py       # Custom exception handling
│   ├── generate_attack.py  # Attack prompt generation
│   ├── run_attack.py       # Attack execution
│   ├── eval_attack.py      # Attack evaluation
│   ├── run_refuse.py       # Refusal testing
│   ├── eval_refuse.py      # Refusal evaluation
│   └── score.py            # Metric calculation
├── sh/                     # Shell script interfaces
│   ├── setup_env.sh        # Environment setup
│   ├── generate_attack.sh  # Attack generation script
│   ├── run_attack.sh       # Attack execution script
│   ├── eval_attack.sh      # Attack evaluation script
│   ├── run_refuse.sh       # Refusal testing script
│   ├── eval_refuse.sh      # Refusal evaluation script
│   └── score.sh            # Scoring script
├── recipes/                # Configuration files
├── logs/                   # Evaluation results
└── .env                    # Environment variables

Pipeline d'évaluation

graph TD
    A[Generate Attack Prompts] --> B[Run Attack Tests]
    B --> C[Evaluate Attack Results]
    D[Run Refuse Tests] --> E[Evaluate Refuse Results]
    C --> F[Calculate Final Scores]
    E --> F
    F --> G[Generate Reports]

🛠️ Installation

Prérequis

• Python 3.8 ou supérieur
• Clé API OpenAI
• Jeton HuggingFace
• Git

Installation étape par étape

1. Cloner le dépôt

   root@kitploit:~

   git clone <repository-url>
   cd redeval
   

2. Installer les dépendances

   root@kitploit:~

   pip install -r requirements.txt
   

3. Configurer l'environnement

   root@kitploit:~

   cp .env.template .env
   # Edit .env with your API credentials
   

4. Vérifier l'installation

   root@kitploit:~

   python -m redeval.cli --help
   

⚙️ Configuration

Variables d'environnement

RedEval utilise des variables d'environnement pour une configuration sécurisée et flexible :

Variables requises

Configuration optionnelle

Configuration des modèles

Fichiers de configuration

Les fichiers de configuration du répertoire recipes/ contrôlent les paramètres d'évaluation :

• attack/base-open.yml - Configuration d'attaque des modèles open source
• attack/base-close.yml - Configuration d'attaque des modèles à source fermée
• attack/eval.yml - Configuration d'évaluation des attaques
• refuse/base-open.yml - Configuration de refus des modèles open source
• refuse/base-close.yml - Configuration de refus des modèles à source fermée
• refuse/eval.yml - Configuration d'évaluation des refus

🚀 Utilisation

Interface en ligne de commande

RedEval fournit une CLI unifiée pour toutes les opérations :

Pipeline complet

# Run full evaluation pipeline
python -m redeval.cli run-pipeline

# Run with specific models
python -m redeval.cli run-pipeline --models "Qwen/Qwen2.5-7B-Instruct" "gpt-4o-mini"

# Run specific phases only
python -m redeval.cli run-pipeline --phases generate_attack run_attack eval_attack

Composants individuels

# Generate attack prompts
python -m redeval.cli generate-attack --config ./recipes/attack/base-close.yml

# Run attack evaluation
python -m redeval.cli run-attack --config ./recipes/attack/base-open.yml --model "Qwen/Qwen2.5-7B-Instruct"

# Evaluate attack results
python -m redeval.cli eval-attack --config ./recipes/attack/eval.yml --log-dir ./logs/attack/HarmBench/direct/model_name

# Run refusal tests
python -m redeval.cli run-refuse --config ./recipes/refuse/base-open.yml --model "Qwen/Qwen2.5-7B-Instruct"

# Evaluate refusal results
python -m redeval.cli eval-refuse --config ./recipes/refuse/eval.yml --log-dir ./logs/refuse/CoCoNot/base/model_name

# Calculate scores
python -m redeval.cli score --log-dir ./logs/attack/HarmBench/direct/model_name --keyword "unsafe"

Interface de scripts shell

Pour les utilisateurs qui préfèrent les scripts shell :

# Set up environment (run first)
source ./sh/setup_env.sh

# Run evaluation phases
./sh/generate_attack.sh    # Generate attack prompts
./sh/run_attack.sh         # Execute attacks
./sh/eval_attack.sh        # Evaluate attack results
./sh/run_refuse.sh         # Run refusal tests
./sh/eval_refuse.sh        # Evaluate refusal results
./sh/score.sh              # Calculate final scores

API Python

Pour un accès programmatique :

from redeval.pipeline import PipelineOrchestrator, PipelinePhase
from redeval.config import EnvironmentConfig

# Initialize configuration
config = EnvironmentConfig.from_env()

# Create pipeline orchestrator
orchestrator = PipelineOrchestrator(config)

# Run complete pipeline
orchestrator.run_complete_pipeline()

# Run specific phases
orchestrator.run_phase(PipelinePhase.GENERATE_ATTACK)
orchestrator.run_phase(PipelinePhase.RUN_ATTACK)

🔒 Fonctionnalités de sécurité

✅ Gestion sécurisée des identifiants

• Aucune clé API codée en dur dans le code source
• Configuration basée sur des variables d'environnement
• Prise en charge du fichier .env avec validation
• Gestion sécurisée des jetons pour l'authentification HuggingFace

✅ Validation des entrées

• Validation des variables d'environnement au démarrage
• Validation des fichiers de configuration
• Validation des noms de modèles et des paramètres

✅ Gestion des erreurs

• Classes d'exceptions personnalisées pour différents types d'erreurs
• Journalisation complète des erreurs
• Gestion élégante des échecs

✅ Bonnes pratiques

• Principe du moindre privilège
• Valeurs par défaut sécurisées
• Journalisation complète sans exposition de données sensibles

📚 Référence de l'API

Commandes CLI

run-pipeline

Exécute le pipeline d'évaluation complet ou des phases spécifiques.

Options :

• --models : Liste des modèles à évaluer
• --phases : Phases spécifiques à exécuter
• --config-dir : Chemin du répertoire de configuration
• --log-dir : Répertoire de sortie pour les journaux

generate-attack

Génère des prompts d'attaque adverses.

Options :

• --config : Chemin du fichier de configuration
• --num-samples : Nombre d'échantillons à générer
• --seed : Graine aléatoire pour la reproductibilité

run-attack

Exécute l'évaluation des attaques contre les modèles cibles.

Options :

• --config : Chemin du fichier de configuration
• --model : Nom du modèle cible
• --num-samples : Nombre d'échantillons à traiter

eval-attack

Évalue les résultats des attaques à l'aide de modèles juge.

Options :

• --config : Chemin du fichier de configuration
• --log-dir : Répertoire contenant les journaux d'attaque

run-refuse

Exécute les tests de capacité de refus.

Options :

• --config : Chemin du fichier de configuration
• --model : Nom du modèle cible
• --num-samples : Nombre d'échantillons à tester
• --split : Division du jeu de données à utiliser

eval-refuse

Évalue les résultats des tests de refus.

Options :

• --config : Chemin du fichier de configuration
• --log-dir : Répertoire contenant les journaux de refus

score

Calcule les scores de sécurité à partir des résultats d'évaluation.

Options :

• --log-dir : Répertoire contenant les journaux d'évaluation
• --keyword : Mot-clé à rechercher dans les résultats

Classes de l'API Python

PipelineOrchestrator

Gestion centralisée du pipeline.

Méthodes :

• run_complete_pipeline() : Exécute le pipeline d'évaluation complet
• run_phase(phase) : Exécute une phase spécifique du pipeline
• get_phase_status(phase) : Obtient le statut d'une phase du pipeline

EnvironmentConfig

Gestion de l'environnement et de la configuration.

Méthodes :

• from_env() : Charge la configuration depuis les variables d'environnement
• validate() : Valide l'exhaustivité de la configuration
• setup_logging() : Configure le système de journalisation

🤝 Contribution

Configuration du développement

1. Fork et clonage

   root@kitploit:~

   git clone https://github.com/knoveleng/redeval.git
   cd redeval
   

2. Créer l'environnement de développement

   root@kitploit:~

   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   pip install -r requirements.txt
   

3. Configurer les hooks pre-commit

   root@kitploit:~

   pip install pre-commit
   pre-commit install
   

Directives de contribution

• Sécurité d'abord : Ne jamais commiter de clés API ou de données sensibles
• Variables d'environnement : Utiliser des variables d'environnement pour toute la configuration
• Gestion des erreurs : Ajouter une gestion appropriée des erreurs avec des exceptions personnalisées
• Documentation : Mettre à jour la documentation pour les nouvelles fonctionnalités
• Tests : Ajouter des tests pour les nouvelles fonctionnalités
• Rétrocompatibilité : Maintenir la compatibilité avec les interfaces existantes

Style de code

• Suivre PEP 8 pour le code Python
• Utiliser des indications de type lorsque c'est approprié
• Ajouter des docstrings complets
• Maintenir des modèles de journalisation cohérents

📄 Licence

Ce projet est sous licence MIT - consultez le fichier LICENSE pour plus de détails.

📚 Citation

Si vous trouvez ce projet utile, pensez à le citer dans vos recherches :

@inproceedings{
   dang2026redbench,
   title={RedBench: A Universal Dataset for Comprehensive Red Teaming of Large Language Models},
   author={Quy-Anh Dang and Chris Ngo and Truong-Son Hy},
   booktitle={ICLR 2026 Workshop on Principled Design for Trustworthy AI - Interpretability, Robustness, and Safety across Modalities},
   year={2026},
   url={https://openreview.net/forum?id=7pZXyk0d07}
}