CEREBRO-RED v2 (Édition Recherche)

Suite autonome de Red Teaming pour LLM locaux

Un cadre de niveau recherche pour la découverte automatisée de vulnérabilités dans les LLM locaux utilisant le Fuzzing Agentique et la Mutation Adversaire Adaptative (AAM).

Objectifs de Recherche

• Implémenter l'algorithme PAIR (Prompt Automatic Iterative Refinement) de arxiv.org/abs/2310.08419
• Évaluation sémantique LLM-as-a-Judge avec raisonnement en chaîne de pensée
• Architecture Telemetry-First pour une analyse de niveau livre blanc
• Support multi-fournisseur LLM (Ollama, Azure OpenAI, OpenAI)

Architecture

Pile Technique

• Backend: FastAPI (async/await), Pydantic (strict types), Uvicorn
• LLM Gateway: litellm (universal adapter for Ollama/Azure/OpenAI)
• Database: SQLite (experiments) + JSONL (audit logs)
• Frontend: React + Vite + TailwindCSS + ShadcnUI + Recharts
• Container: Docker + Docker Compose

Architecture du système montrant les principaux composants et le flux de données

Modules Principaux

1. Orchestrator (backend/core/engine.py): Traitement par lots asynchrone avec backoff exponentiel
2. Mutator (backend/core/mutator.py): Algorithme PAIR avec stratégies de mutation
3. Judge (backend/core/judge.py): LLM-as-a-Judge avec évaluation CoT
4. Telemetry (backend/core/telemetry.py): Journal d'audit JSONL thread-safe

Tableau de Bord Frontend

Le frontend basé sur React offre une interface complète pour gérer les expériences, surveiller la progression et analyser les résultats.

Interface principale du tableau de bord montrant l'aperçu des expériences et les statistiques

Vue de gestion des expériences avec mises à jour en temps réel et liste des expériences

Aperçu complet de l'interface utilisateur montrant toutes les fonctionnalités disponibles

Résultats et Analyse des Expériences

Vue des résultats affichant les issues des expériences, les découvertes de vulnérabilités et l'analyse détaillée

Panneau de paramètres et de configuration pour personnaliser les paramètres d'expérience

Surveillance en Temps Réel

Tableau de bord de surveillance en temps réel avec progression en direct des expériences et indicateurs d'état

Vue de télémétrie montrant les journaux d'audit détaillés, les événements système et les métriques de performance

Vue détaillée des journaux avec capacités de filtrage et de recherche

Tableau de bord des métriques de performance et des statistiques

Aperçu de l'état du système montrant les vérifications d'intégrité et l'état des composants

Documentation API

Interface de documentation API interactive avec explorateur de points d'accès

Pour une documentation détaillée de l'architecture, voir docs/ARCHITECTURE.md.

Démarrage Rapide

Prérequis

• Docker 24.0+
• Docker Compose 2.20+
• Ollama en cours d'exécution sur l'hôte (ou clés API Azure/OpenAI)

Configuration Docker

Si Docker n'est pas en cours d'exécution, démarrez le démon 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

**Vérifiez que Docker est en cours d'exécution** :```bash
docker --version
docker compose version

Installation

1. Cloner le dépôt: ```bash git clone https://github.com/Leviticus-Triage/cerebro-red-v2.git cd cerebro-red-v2

2. Configurer l'environnement : ```bash cp .env.example .env

   Edit .env with your LLM provider credentials

3. IMPORTANT: Vérifiez le port 8000 ```bash

   Falls Port 8000 belegt ist:

   lsof -i :8000 # Finde Prozess

   Oder ändere Port in .env: CEREBRO_PORT=8001

4. Démarrer le backend (IMPORTANT - doit fonctionner !) : ```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. Prüfe Backend-Status: ```bash curl http://localhost:9000/health

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

6. Exécuter des tests rapides : ```bash ./QUICK_TEST_EXAMPLES.sh

7. Accédez au tableau de bord :

   • Backend API : http://localhost:9000
   • Frontend UI : http://localhost:3000 (optionnel : docker compose up -d cerebro-frontend)
   • API Docs : http://localhost:9000/docs

   

   Interface utilisateur du frontend montrant la gestion et le suivi des expériences

---

Démarrage rapide : Déploiement local vs Cloud

Déploiement local (Ollama)

Idéal pour : tests axés sur la confidentialité, aucun coût d'API, fonctionnement hors ligne.```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

### Déploiement cloud (OpenAI)

Idéal pour : Réponses plus rapides, mutations de meilleure qualité, tests en production.```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