RedEval - Framework zur Bewertung der LLM-Sicherheit

Ein umfassendes Framework zur Bewertung der Sicherheit großer Sprachmodelle (LLMs) durch systematische Angriffs- und Verweigerungstests. RedEval bietet eine einheitliche, sichere und erweiterbare Plattform zur Bewertung der Robustheit von LLMs gegenüber adversarialen Prompts und schädlichen Inhalten. Es ist Teil des Papers „RedBench: A Universal Dataset for Comprehensive Red Teaming of Large Language Models“, einem universellen Datensatz für umfassendes Red Teaming von LLMs.

📦 Datensatz: Der RedBench-Datensatz ist öffentlich auf HuggingFace unter knoveleng/redbench verfügbar. Er enthält umfassende Red-Teaming-Prompts für mehrere Sicherheitskategorien und -domänen.

🚀 Schnellstart

1. Umgebung einrichten

# 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. API-Schlüssel konfigurieren

Bearbeite die .env-Datei mit deinen Zugangsdaten:

OPENAI_API_KEY=your_openai_api_key_here
HUGGINGFACE_TOKEN=your_huggingface_token_here

3. Evaluierung ausführen

# 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

📋 Inhaltsverzeichnis

• Überblick
• Architektur
• Installation
• Konfiguration
• Verwendung
• Sicherheitsfunktionen
• API-Referenz
• Mitwirken
• Lizenz

🎯 Überblick

RedEval bewertet die LLM-Sicherheit anhand zweier sich ergänzender Ansätze:

🔴 Angriffsphase

Testet die Verwundbarkeit von LLMs gegenüber adversarialen Prompts mithilfe verschiedener Jailbreaking-Techniken:

• Direkte Angriffe: Unkomplizierte schädliche Prompts
• Menschliche Jailbreaks: Von Menschen entwickelte Umgehungstechniken
• Zero-Shot-Angriffe: Automatisierte Generierung adversarialer Prompts

🛡️ Verweigerungsphase

Bewertet die Fähigkeit von LLMs, schädliche Anfragen über mehrere Sicherheitsdatensätze hinweg angemessen abzulehnen:

• CoCoNot: Kontextbewusste Inhaltsmoderation
• SGXSTest: Prüfung von Sicherheitsrichtlinien
• XSTest: Domänenübergreifende Sicherheitstests
• ORBench: Objektive Verweigerungs-Benchmarks

📊 Bewertung

Berechnet umfassende Sicherheitsmetriken, die Angriffs- und Verweigerungsleistung kombinieren.

🏗️ Architektur

Kernkomponenten

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

Evaluierungspipeline

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

Voraussetzungen

• Python 3.8 oder höher
• OpenAI-API-Schlüssel
• HuggingFace-Token
• Git

Schritt-für-Schritt-Installation

1. Repository klonen

   root@kitploit:~

   git clone <repository-url>
   cd redeval
   

2. Abhängigkeiten installieren

   root@kitploit:~

   pip install -r requirements.txt
   

3. Umgebung konfigurieren

   root@kitploit:~

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

4. Installation überprüfen

   root@kitploit:~

   python -m redeval.cli --help
   

⚙️ Konfiguration

Umgebungsvariablen

RedEval verwendet Umgebungsvariablen für eine sichere und flexible Konfiguration:

Erforderliche Variablen

Optionale Konfiguration

Modellkonfiguration

Konfigurationsdateien

Konfigurationsdateien im Verzeichnis recipes/ steuern die Evaluierungsparameter:

• attack/base-open.yml - Angriffskonfiguration für Open-Source-Modelle
• attack/base-close.yml - Angriffskonfiguration für Closed-Source-Modelle
• attack/eval.yml - Konfiguration der Angriffsbewertung
• refuse/base-open.yml - Verweigerungskonfiguration für Open-Source-Modelle
• refuse/base-close.yml - Verweigerungskonfiguration für Closed-Source-Modelle
• refuse/eval.yml - Konfiguration der Verweigerungsbewertung

🚀 Verwendung

Befehlszeilenschnittstelle

RedEval bietet eine einheitliche CLI für alle Vorgänge:

Vollständige Pipeline

# 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

Einzelne Komponenten

# 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"

Shell-Skript-Schnittstelle

Für Benutzer, die Shell-Skripte bevorzugen:

# 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

Python-API

Für den programmatischen Zugriff:

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)

🔒 Sicherheitsfunktionen

✅ Sichere Verwaltung von Zugangsdaten

• Keine hartcodierten API-Schlüssel im Quellcode
• Konfiguration über Umgebungsvariablen
• .env-Dateiunterstützung mit Validierung
• Sicheres Token-Handling für die HuggingFace-Authentifizierung

✅ Eingabevalidierung

• Validierung der Umgebungsvariablen beim Start
• Validierung der Konfigurationsdateien
• Validierung von Modellnamen und -parametern

✅ Fehlerbehandlung

• Benutzerdefinierte Ausnahmeklassen für verschiedene Fehlertypen
• Umfassende Fehlerprotokollierung
• Sanftes Fehlerverhalten

✅ Bewährte Praktiken

• Prinzip der geringsten Rechte
• Sichere Standardeinstellungen
• Umfassende Protokollierung ohne Offenlegung sensibler Daten

📚 API-Referenz

CLI-Befehle

run-pipeline

Führt die vollständige Evaluierungspipeline oder bestimmte Phasen aus.

Optionen:

• --models: Liste der zu bewertenden Modelle
• --phases: Bestimmte auszuführende Phasen
• --config-dir: Pfad zum Konfigurationsverzeichnis
• --log-dir: Ausgabeverzeichnis für Logs

generate-attack

Generiert adversariale Angriffs-Prompts.

Optionen:

• --config: Pfad zur Konfigurationsdatei
• --num-samples: Anzahl der zu generierenden Stichproben
• --seed: Zufalls-Seed für die Reproduzierbarkeit

run-attack

Führt die Angriffsbewertung gegen Zielmodelle aus.

Optionen:

• --config: Pfad zur Konfigurationsdatei
• --model: Name des Zielmodells
• --num-samples: Anzahl der zu verarbeitenden Stichproben

eval-attack

Bewertet Angriffsergebnisse mithilfe von Judge-Modellen.

Optionen:

• --config: Pfad zur Konfigurationsdatei
• --log-dir: Verzeichnis mit den Angriffs-Logs

run-refuse

Führt Tests der Verweigerungsfähigkeit durch.

Optionen:

• --config: Pfad zur Konfigurationsdatei
• --model: Name des Zielmodells
• --num-samples: Anzahl der zu testenden Stichproben
• --split: Zu verwendender Datensatz-Split

eval-refuse

Bewertet die Ergebnisse der Verweigerungstests.

Optionen:

• --config: Pfad zur Konfigurationsdatei
• --log-dir: Verzeichnis mit den Verweigerungs-Logs

score

Berechnet Sicherheitsbewertungen aus den Evaluierungsergebnissen.

Optionen:

• --log-dir: Verzeichnis mit den Evaluierungs-Logs
• --keyword: Schlüsselwort, nach dem in den Ergebnissen gesucht werden soll

Python-API-Klassen

PipelineOrchestrator

Zentrale Pipeline-Verwaltung.

Methoden:

• run_complete_pipeline(): Führt die vollständige Evaluierungspipeline aus
• run_phase(phase): Führt eine bestimmte Pipeline-Phase aus
• get_phase_status(phase): Ruft den Status einer Pipeline-Phase ab

EnvironmentConfig

Verwaltung von Umgebung und Konfiguration.

Methoden:

• from_env(): Lädt die Konfiguration aus Umgebungsvariablen
• validate(): Validiert die Vollständigkeit der Konfiguration
• setup_logging(): Konfiguriert das Logging-System

🤝 Mitwirken

Einrichtung der Entwicklungsumgebung

1. Forken und Klonen

   root@kitploit:~

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

2. Entwicklungsumgebung erstellen

   root@kitploit:~

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

3. Pre-Commit-Hooks einrichten

   root@kitploit:~

   pip install pre-commit
   pre-commit install
   

Richtlinien für Beiträge

• Sicherheit zuerst: Committe niemals API-Schlüssel oder sensible Daten
• Umgebungsvariablen: Verwende Umgebungsvariablen für die gesamte Konfiguration
• Fehlerbehandlung: Füge eine ordnungsgemäße Fehlerbehandlung mit benutzerdefinierten Ausnahmen hinzu
• Dokumentation: Aktualisiere die Dokumentation für neue Funktionen
• Tests: Füge Tests für neue Funktionen hinzu
• Abwärtskompatibilität: Halte die Kompatibilität mit vorhandenen Schnittstellen aufrecht

Code-Stil

• Befolge PEP 8 für Python-Code
• Verwende Typannotationen, wo es angebracht ist
• Füge umfassende Docstrings hinzu
• Verwende konsistente Logging-Muster

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die Datei LICENSE für Details.

📚 Zitieren

Wenn du dieses Projekt nützlich findest, ziehe bitte in Betracht, es in deiner Forschung zu zitieren:

@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}
}