CEREBRO-RED v2 (Edizione di Ricerca)

Suite Autonoma di Red Teaming per LLM Locali

Un framework di livello di ricerca per la scoperta automatizzata di vulnerabilità in LLM locali utilizzando Agentic Fuzzing e Adaptive Adversarial Mutation (AAM).

Obiettivi di Ricerca

• Implementare l'Algoritmo PAIR (Prompt Automatic Iterative Refinement) da arxiv.org/abs/2310.08419
• Valutazione semantica LLM-as-a-Judge con ragionamento Chain-of-Thought
• Architettura Telemetry-First per analisi di livello whitepaper
• Supporto multi-provider per LLM (Ollama, Azure OpenAI, OpenAI)

Architettura

Stack Tecnologico

• Backend: FastAPI (async/await), Pydantic (tipi rigorosi), Uvicorn
• Gateway LLM: litellm (adattatore universale per Ollama/Azure/OpenAI)
• Database: SQLite (esperimenti) + JSONL (log di audit)
• Frontend: React + Vite + TailwindCSS + ShadcnUI + Recharts
• Container: Docker + Docker Compose

Architettura del sistema che mostra i componenti principali e il flusso di dati

Moduli Principali

1. Orchestrator (backend/core/engine.py): Elaborazione batch asincrona con backoff esponenziale
2. Mutator (backend/core/mutator.py): Algoritmo PAIR con strategie di mutazione
3. Judge (backend/core/judge.py): LLM-as-a-Judge con valutazione CoT
4. Telemetry (backend/core/telemetry.py): Logger di audit JSONL thread-safe

Dashboard Frontend

Il frontend basato su React fornisce un'interfaccia completa per gestire esperimenti, monitorare il progresso e analizzare i risultati.

Interfaccia principale della dashboard che mostra panoramica degli esperimenti e statistiche

Vista di gestione degli esperimenti con aggiornamenti di stato in tempo reale e elenco esperimenti

Panoramica completa dell'interfaccia utente che mostra tutte le funzionalità disponibili

Risultati e Analisi degli Esperimenti

Vista dei risultati che mostra gli esiti degli esperimenti, i risultati delle vulnerabilità e l'analisi dettagliata

Pannello delle impostazioni e configurazione per personalizzare i parametri dell'esperimento

Monitoraggio in Tempo Reale

Dashboard di monitoraggio in tempo reale con progresso live degli esperimenti e indicatori di stato

Vista di telemetria che mostra log di audit dettagliati, eventi di sistema e metriche di performance

Vista dettagliata dei log con capacità di filtro e ricerca

Dashboard di metriche di performance e statistiche

Panoramica dello stato del sistema che mostra controlli di integrità e stato dei componenti

Documentazione API

Interfaccia di documentazione API interattiva con esploratore di endpoint

Per documentazione dettagliata dell'architettura, vedere docs/ARCHITECTURE.md.

Avvio Rapido

Prerequisiti

• Docker 24.0+
• Docker Compose 2.20+
• Ollama in esecuzione sull'host (o chiavi API Azure/OpenAI)

Configurazione Docker

Se Docker non è in esecuzione, avvia il demone Docker:```bash

Start Docker daemon

sudo systemctl start docker

Enable Docker to start on boot

sudo systemctl enable docker

Add your user to the docker group (to run Docker without sudo)

sudo usermod -aG docker $USER

Apply group changes (logout/login or use newgrp)

newgrp docker

OR logout and login again for changes to take effect

**Verifica che Docker sia in esecuzione**:```bash
docker --version
docker compose version

Installazione

1. Clona il repository: ```bash git clone https://github.com/Leviticus-Triage/cerebro-red-v2.git cd cerebro-red-v2

2. Configura l'ambiente: ```bash cp .env.example .env

   Edit .env with your LLM provider credentials

3. IMPORTANTE: Controlla la porta 8000 ```bash

   Falls Port 8000 belegt ist:

   lsof -i :8000 # Finde Prozess

   Oder ändere Port in .env: CEREBRO_PORT=8001

4. Avvia il Backend (IMPORTANTE - deve essere in esecuzione!): ```bash

   Option 1: Automatisch (empfohlen)

   ./START_BACKEND.sh

   Option 2: Docker

   docker compose up -d cerebro-backend

   Option 3: Lokal

   cd backend uvicorn main:app --reload --port 9000

5. Controlla lo stato del backend: ```bash curl http://localhost:9000/health

   Sollte {"status": "healthy", ...} zurückgeben

6. Esegui test rapidi: ```bash ./QUICK_TEST_EXAMPLES.sh

7. Accedi alla dashboard:

   • API backend: http://localhost:9000
   • Interfaccia frontend: http://localhost:3000 (opzionale: docker compose up -d cerebro-frontend)
   • Documentazione API: http://localhost:9000/docs

   

   Interfaccia utente frontend che mostra la gestione degli esperimenti e il monitoraggio

---

Avvio rapido: Distribuzione locale vs Cloud

Distribuzione locale (Ollama)

Ideale per: test incentrati sulla privacy, nessun costo API, funzionamento offline.```bash

1. Install and start Ollama

curl -fsSL https://ollama.ai/install.sh | sh ollama pull llama3.2:3b ollama serve

2. Configure .env for local

cat > .env << 'EOF' TARGET_MODEL=ollama/llama3.2:3b ATTACKER_MODEL=ollama/llama3.2:3b JUDGE_MODEL=ollama/llama3.2:3b OLLAMA_BASE_URL=http://host.docker.internal:11434

Relaxed circuit breaker for local (slower responses)

CIRCUIT_BREAKER_FAILURE_THRESHOLD=15 CIRCUIT_BREAKER_TIMEOUT=120 CIRCUIT_BREAKER_JITTER_ENABLED=true EOF

3. Start services

docker compose up -d

4. Verify

curl http://localhost:9000/health | jq

### Distribuzione nel Cloud (OpenAI)

Ideale per: risposte più rapide, mutazioni di qualità superiore, test di produzione.```bash
# 1. Configure .env for cloud
cat > .env << 'EOF'
TARGET_MODEL=openai/gpt-4o-mini
ATTACKER_MODEL=openai/gpt-4o-mini
JUDGE_MODEL=openai/gpt-4o-mini
OPENAI_API_KEY=sk-your-key-here

# Standard circuit breaker for cloud
CIRCUIT_BREAKER_FAILURE_THRESHOLD=10
CIRCUIT_BREAKER_TIMEOUT=60
CIRCUIT_BREAKER_JITTER_ENABLED=true
EOF

# 2. Start services
docker compose up -d