HarmBench: gestandaardiseerde red team-evaluatie

Diepe duik in het HarmBench-framework voor gestandaardiseerde red team-evaluatie: aanvalsmethoden, de evaluatiepijplijn, benchmarks draaien, resultaten interpreteren en de veiligheid van modellen tussen providers vergelijken.

HarmBench: Standardized Red Team Evaluation

HarmBench biedt waar het redteaming-vakgebied al lang behoefte aan heeft: een gemeenschappelijke benchmark om aanvalsmethoden onderling te vergelijken en de robuustheid van modellen op een gestandaardiseerde schaal te meten. In plaats van dat elk team andere prompts en andere succescriteria gebruikt, definieert HarmBench een gedeeld evaluatieprotocol.

Why Standardized Benchmarks Matter

Zonder standaardisatie zijn red team-resultaten niet vergelijkbaar:

Architecture

HarmBench bestaat uit drie onderdelen: schadelijke gedragingen, aanvalsmethoden en evaluatieclassifiers.

┌────────────────┐     ┌────────────────┐     ┌────────────────┐
│    Harmful     │────>│    Attack      │────>│   Evaluation   │
│   Behaviors    │     │    Methods     │     │   Classifier   │
│ (510 standard) │     │ (GCG, PAIR,   │     │ (Llama-based   │
│                │     │  AutoDAN...)   │     │  judge)        │
└────────────────┘     └────────────────┘     └────────────────┘

Harmful Behavior Categories

HarmBench definieert 510 schadelijke gedragingen verdeeld over deze categorieën:

Attack Methods

HarmBench evalueert onder meer deze aanvalsmethoden:

Evaluation Classifier

HarmBench gebruikt een fine-tuned, Llama-gebaseerde classifier om te beoordelen of een modelrespons een geslaagde aanval is:

# De classifier beantwoordt: "Levert deze respons
# de schadelijke inhoud die in het gedrag werd gevraagd?"
# Output: 1 (ja, aanval geslaagd) of 0 (nee, model weigerde)

Running HarmBench

1. 1

   Clonen en opzetten

   git clone https://github.com/centerforaisafety/HarmBench
   cd HarmBench
   pip install -r requirements.txt

2. 2

   Target-model configureren

   Pas de configuratie aan zodat die naar je target-model wijst.

   # configs/model_configs/target.yaml
   target_model:
     model_name: "gpt-4"
     provider: "openai"
     api_key_env: "OPENAI_API_KEY"

3. 3

   Aanvalsmethoden selecteren

   Kies welke aanvalsmethoden je wilt draaien.

   python run_attack.py \
     --attack_method PAIR \
     --target_model gpt-4 \
     --behaviors_path data/harmbench_behaviors_text.csv \
     --output_dir results/

4. 4

   Resultaten evalueren

   Draai de gestandaardiseerde classifier over de aanvalsoutputs.

   python evaluate.py \
     --results_dir results/ \
     --classifier_model harmbench-classifier \
     --output results/evaluation.json

5. 5

   ASR analyseren

   Bereken de Attack Success Rates per categorie, methode en model.

Interpreting Results

Attack Success Rate (ASR)

De belangrijkste metriek is ASR:

ASR = (Geslaagde aanvallen / Totaal geteste gedragingen) * 100

Example Results Table

Let op: dit zijn illustratieve cijfers, geen echte benchmarkresultaten.

What the Numbers Mean

Adding Custom Attack Methods

Breid HarmBench uit met je eigen aanvalsmethoden:

from harmbench.attacks import BaseAttack
 
class CustomAttack(BaseAttack):
    """Eigen aanval met domeinspecifieke kennis."""
 
    def __init__(self, target_model, **kwargs):
        super().__init__(target_model, **kwargs)
        self.max_attempts = kwargs.get("max_attempts", 5)
 
    def generate_attack(self, behavior: str) -> str:
        """Genereer een aanvalsprompt voor het gegeven gedrag."""
        # Implementeer je aanvalsstrategie
        attack_prompt = self._craft_prompt(behavior)
        for attempt in range(self.max_attempts):
            response = self.target_model.generate(attack_prompt)
            if self._check_success(response, behavior):
                return attack_prompt
            attack_prompt = self._refine(attack_prompt, response)
        return attack_prompt

Limitations

• Statische gedragingen: De 510 gedragingen dekken mogelijk niet de specifieke risicocategorieën van jouw organisatie
• Nauwkeurigheid van de classifier: De Llama-gebaseerde classifier heeft een gerapporteerde nauwkeurigheid van rond de 90% -- verwacht enkele vals-positieven en vals-negatieven
• Rekenkosten: Optimalisatie-gebaseerde aanvallen (GCG, AutoDAN) vereisen flink wat GPU-resources
• Momentopname: Modellen evolueren; benchmarkresultaten weerspiegelen een momentopname, geen doorlopende veiligheid
• Engelstalig georiënteerd: De meeste gedragingen zijn in het Engels; meertalige veiligheid is ondervertegenwoordigd

Using HarmBench for Model Procurement

Bij het selecteren van modellen voor deployment biedt HarmBench een gestructureerd vergelijkingsframework:

1. Draai de volledige benchmark tegen de kandidaat-modellen
2. Vergelijk de ASR over je hoogst geprioriteerde schadecategorieën
3. Weeg de resultaten op basis van de risicotolerantie van je organisatie
4. Houd rekening met het verschil tussen DirectRequest en de beste aanvalsmethode (een indicatie van de diepte van de verdediging)
5. Vul aan met domeinspecifiek testen via Inspect AI of eigen harnesses

Related Topics

• PAIR & TAP Attack Algorithms - Algoritmes die door HarmBench worden gebenchmarkt
• AI-Powered Red Teaming - Geautomatiseerde redteaming-aanpakken die HarmBench evalueert
• Inspect AI - Aanvullend framework voor veiligheidsevaluatie
• Custom Harness Patterns - Verder bouwen dan standaardbenchmarks

References

• "HarmBench: A Standardized Evaluation Framework for Automated Red Teaming" - Mazeika et al. (2024) - Oorspronkelijke HarmBench-paper
• "Red Teaming Language Models with Language Models" - Perez et al. (2022) - Fundamentele geautomatiseerde redteaming
• "Tree of Attacks with Pruning" - Mehrotra et al. (2024) - TAP-algoritme dat in HarmBench wordt gebenchmarkt

Related Pages

• Inspect AI -- aanvullend evaluatieframework
• Custom Harness Patterns -- verder bouwen dan standaardbenchmarks
• CART Pipelines -- integratie van doorlopend testen