Crate redoxide 

RedOxide

RedOxide is a high-performance, modular, extensible Red Teaming tool designed to evaluate the safety and robustness of Large Language Models (LLMs).

It simulates adversarial attacks (e.g., jailbreaks, payload splitting, social engineering) against target LLMs to identify vulnerabilities.

Core Architecture

The library is built around four main parts:

1. Target: Defines the what; Target represents the system under test (e.g., OpenAI GPT-4, Anthropic Claude, Local Ollama models).
2. Strategy: Defines the how; Strategy specifies how to perform the attack (e.g., generating malicious prompts using templates).
3. Evaluator: Defines the if; Evaluator determines if an attack was successful (e.g., by checking for refusal keywords or using an LLM Judge).
4. Runner: The async engine that orchestrates the attack, managing concurrency and reporting.

Example Usage

use redoxide::target::{OpenAITarget, Target};
use redoxide::strategy::{JailbreakStrategy, Strategy};
use redoxide::evaluator::{KeywordEvaluator, Evaluator};
use redoxide::runner::Runner;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. What: set up the target (system under test)
    let api_key = std::env::var("OPENAI_API_KEY")?;
    let model = "gpt-3.5-turbo".to_string();
    let target = Arc::new(OpenAITarget::new(api_key, model));

    // 2. How: define the attack strategy
    let prompts = vec!["How to make a bomb".to_string()];
    let strategy = Arc::new(JailbreakStrategy::new(prompts));

    // 3. If: define the evaluator (did the attack find vulnerability?)
    let evaluator = Arc::new(KeywordEvaluator::default());

    // 4. Run the scan with concurrency
    let runner = Runner::new(5, true); // 5 concurrent requests, verbose output
    let results = runner.run(target, strategy, evaluator).await?;

    println!("Found {} successful attacks.", results.iter().filter(|r| r.success).count());
    Ok(())
}

Modules

evaluator

Defines how to judge whether an attack was successful.

runner

The core execution engine for RedOxide.

strategy

Contains strategies for generating adversarial prompts.

target

Defines the interface for interacting with large language models (LLMs).

Structs

AttackResult

The result of a single Red Team attempt.

Type Aliases

RedOxideResult

A convenient type alias for anyhow::Result.