PHANTOM BRAIN v0.9

Strumento di analisi per penetration testing basato su AI offline con integrazione hardware reale

Analisi LLM locale (tramite Ollama) per WiFi, Sub-GHz, NFC/RFID e catture WPA2 — nessuna connessione internet richiesta, nessuna API cloud, 100% offline. Il LLM principale viene eseguito su un PC Windows. Il Raspberry Pi agisce come nodo secondario leggero (cattura live + solo phi3:mini).

Hardware supportato: Flipper Zero · WiFi Pineapple MK7 · Proxmark3 · Raspberry Pi 4 (Kali Linux) · Atheros AR9271

Modelli: mistral:7b-instruct · deepseek-r1:7b · phi3:mini

Licenza: GPL-3.0 | Autore: Otto | Comunità: AI Tinkerers

⚠️ Progetto sperimentale — non per uso produttivo. L'analisi AI assiste i ricercatori umani; non sostituisce il controllo manuale. Verifica sempre i risultati in modo indipendente.

Cosa Phantom Brain È e NON È

💡 Ogni report generato dall'AI dovrebbe essere considerato un punto di partenza, non un verdetto finale. I LLM possono allucinare vulnerabilità. L'output strutturato del parser (senza AI) è sempre più affidabile.

Architettura del Sistema

CAMPO (Mobile):
┌──────────────────┐
│  Flipper Zero    │ ──► Sub-GHz (.sub), NFC (.nfc), scansione WiFi
└──────────────────┘
┌──────────────────┐
│  WiFi Pineapple  │ ──► Handshake WPA2 (.pcap), deauth, PMKID
└──────────────────┘
┌──────────────────┐
│  Proxmark3       │ ──► RFID/NFC avanzato (EM410x, MIFARE, EMV)
└──────────────────┘

BASE — NODO PRIMARIO (richiesto per funzionalità completa):
┌──────────────────────────────────────────────────────┐
│  PC Windows (o desktop Linux)                        │
│  Python 3.11+ · Ollama · Flask API                  │
│  Esegue: mistral:7b-instruct, deepseek-r1:7b           │
│  ► CLI PHANTOM BRAIN, analisi completa, report       │
└──────────────────────────────────────────────────────┘

BASE — NODO SECONDARIO (opzionale, leggero):
┌──────────────────────────────────────────────────────┐
│  Raspberry Pi 4 (Kali Linux)                         │
│  Ollama · Atheros AR9271                             │
│  Esegue: solo phi3:mini (mistral:7b troppo pesante per Pi) │
│  ► Cattura WiFi live · inferenza locale leggera      │
│  NOTA: si connette all'Ollama del PC per modelli pesanti│
└──────────────────────────────────────────────────────┘

⚠️ Nota sull'architettura: Il Raspberry Pi non esegue l'intero stack di Phantom Brain in modo autonomo. Per un'analisi completa con mistral:7b-instruct o deepseek-r1:7b, è necessario un PC con Ollama. Il Pi funge da nodo di cattura e può eseguire phi3:mini solo per inferenza offline leggera.

Pipeline di Analisi (v0.9)

``` input → classificatore → tool.run() → ToolResult(rischio, risultati) → Ollama ```

Ogni tipo di cattura passa attraverso il suo tool specifico prima di raggiungere il LLM. Il tool struttura l'output con un livello di rischio e i risultati chiave, arricchendo il contesto inviato a Ollama.

Funzionalità

WiFi / Marauder

• Parsing dei log Marauder
• Rilevamento di reti WPS vulnerabili
• Identificazione di reti nascoste
• Statistiche di sicurezza

Sub-GHz / Flipper Zero

• Parser file `.sub` (`sub_ghz_parser.py`)
• Estrazione: protocollo, frequenza, chiavi, pacchetti
• Supporto: Security+ 2.0, Rolling Code, Fixed Code
• Analizzatore di pattern tra catture (`sub_ghz_analyzer.py`)

NFC / Flipper Zero + Proxmark3

• Parser file `.nfc` (`nfc_parser.py`)
• Supporto: MIFARE Classic 1K/4K, MIFARE Plus, NTAG, FeliCa, EMV
• Analizzatore di vulnerabilità (`nfc_analyzer.py`)
• Rilevamento: Darkside, Hardnested, Reader Auth Bypass
• Analisi speciale per SUBE (trasporto pubblico)
• Parser output Proxmark3 (`proxmark_parser.py`)

WPA2 / WiFi Pineapple

• Parser PCAP con Scapy (`pcap_parser_v2.py`)
• Estrazione: BSSID, SSID, frame EAPOL, PMKID
• Validazione degli handshake completi
• Pipeline completa: `hcxpcapngtool` → `hashcat -m 22000`

Sistema di Strumenti (v0.9)

• `tools/base_tool.py` — contratto unificato `BaseTool` + `ToolResult`
• `ToolResult` con `rischio` (CRITICO/ALTO/MEDIO/BASSO) e `risultati` strutturati
• `tools/registry.py` — registro centrale, invia il tool corretto in base al tipo
• `tools/classifier.py` — rilevamento automatico per estensione e contenuto
• 14/14 test superati con fixture reali (`pytest tests/test_tools.py`)

Database e Report

• SQLite per la cronologia delle analisi (`db_manager.py`)
• Report in testo semplice con timestamp
• Ricerca per UID/BSSID, filtro per livello di rischio
• Statistiche di analisi

API REST Flask

• `flask_api.py` in esecuzione sulla porta 5000
• `GET /status` — controlla Ollama e i modelli disponibili
• `POST /upload` — riceve file `.pcap`, `.nfc`, `.sub`
• `POST /analyze` — analizza con Ollama e salva in SQLite
• `GET /analysis/` — recupera un'analisi salvata per ID

Modelli AI Supportati

Nota: I benchmark di velocità sono stati misurati su un PC con 32 GB di RAM (solo CPU, nessuna GPU). L'accelerazione GPU tramite CUDA/ROCm ridurrà significativamente il tempo di inferenza. Il Pi può eseguire solo phi3:mini in modo affidabile — mistral:7b causa throttling termico e OOM su Pi 4B 8GB.

Tutti i modelli funzionano 100% offline tramite Ollama — nessuna connessione internet richiesta.

Struttura dei File

phantom-brain/
├── phantom_brain.py          # CLI principale - punto di ingresso
├── flask_api.py              # API REST Flask
├── db_manager.py             # SQLite - cronologia report
├── pcap_parser_v2.py         # Parser WPA2/PCAP
├── proxmark_parser.py        # Parser output Proxmark3
├── nfc_parser.py             # Parser file .nfc di Flipper
├── nfc_analyzer.py           # Analizzatore vulnerabilità NFC
├── sub_ghz_parser.py         # Parser file .sub di Flipper
├── sub_ghz_analyzer.py       # Analizzatore pattern Sub-GHz
├── exploit_guide.py          # Guide allo sfruttamento senza AI
├── proxmark_launch.bat       # Script di avvio Proxmark3 (Windows)
├── config.yaml.example       # Template di configurazione
├── requirements.txt          # Dipendenze Python
├── tools/                    # Sistema modulare di strumenti (v0.9)
│   ├── base_tool.py          # BaseTool + ToolResult con rischio/risultati
│   ├── classifier.py         # Rilevamento automatico tipo di cattura
│   ├── registry.py           # Registro centrale degli strumenti
│   ├── proxmark_tool.py      # Tool Proxmark3
│   ├── nfc_tool.py           # Tool NFC
│   ├── wpa2_tool.py          # Tool WPA2/PCAP
│   └── subghz_tool.py        # Tool Sub-GHz
├── tests/                    # Test automatizzati (14/14 superati)
│   └── test_tools.py
├── prompts/                  # Prompt di sistema separati per tipo
│   └── system_prompts.py
├── benchmarks/               # Suite di benchmark
│   ├── dataset/              # Catture con risultati attesi
│   ├── results/              # Report JSON e markdown
│   ├── benchmark_runner.py
│   └── run_benchmark.py
├── reportes/                 # Report generati (ignorati in git)
├── pcap/                     # Catture WPA2 (ignorate in git)
└── archive/                  # Versioni precedenti

Installazione

```bash git clone https://github.com/OttoyRocky/phantom-brain.git cd phantom-brain pip install -r requirements.txt cp config.yaml.example config.yaml ollama pull mistral:7b-instruct ```

Raspberry Pi (Kali Linux)

```bash echo 'export OLLAMA_MODELS=/media/kali/discoexterno/ollama' >> ~/.zshrc source ~/.zshrc ollama pull phi3:mini

sudo fallocate -l 2G /swapfile sudo chmod 600 /swapfile sudo mkswap /swapfile sudo swapon /swapfile echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

cd /media/kali/discoexterno git clone https://github.com/OttoyRocky/phantom-brain.git ```

Utilizzo

```bash python phantom_brain.py python flask_api.py curl http://127.0.0.1:5000/status python -m pytest tests/test_tools.py -v ```

Menu Principale

```

1. Incolla testo manualmente
2. Leggi file generico (scan.txt, nmap, ecc.)
3. Leggi log Flipper Zero / Marauder (.log)
4. Analizza catture Sub-GHz (.sub)
5. Analizza catture NFC (.nfc)
6. Analizza catture Handshake WPA2 (.pcap)
7. Analizza cattura Proxmark3 (incolla direttamente l'output)
8. Visualizza cronologia report
9. Guide allo sfruttamento (senza analisi AI)
10. Cattura WiFi live - Atheros AR9271 (solo Raspberry Pi)
11. Genera wordlist intelligente con AI (basata su SSID) ```

Generazione di Wordlist Intelligente con AI

• Genera dizionari personalizzati utilizzando AI locale (Ollama) dall'SSID target.
• Input: SSID + contesto opzionale (paese, ISP, anno, ecc.).
• Output: `wordlist__.txt` nella directory di lavoro corrente.
• Pattern: varianti SSID, anni 2020-2025, contesto argentino (calcio, date, ISP), simboli come `!@#`.
• Stampa il comando pronto all'uso: `hashcat -m 22000 captura.hc22000 wordlist__.txt`

Roadmap

Requisiti

PC Windows (Nodo primario — richiesto per funzionalità completa):

• Python 3.11+
• Ollama con mistral:7b-instruct (raccomandato) o deepseek-r1:7b
• 8 GB RAM minimo · 16 GB+ raccomandati
• pip install -r requirements.txt

Raspberry Pi 4 (Nodo secondario — opzionale):

• Kali Linux
• Python 3.11+
• Ollama con solo phi3:mini (modelli più pesanti non supportati)
• Modello con 8 GB RAM raccomandato · 2 GB swap richiesto
• Adattatore Atheros AR9271 per cattura live (Opzione 10)

Disclaimer

Questo progetto è destinato esclusivamente ad ambienti di laboratorio autorizzati. L'uso di questi strumenti contro reti o dispositivi senza esplicita autorizzazione scritta è illegale e non etico.

L'analisi generata dall'AI non sostituisce una valutazione professionale della sicurezza. Tutti i risultati devono essere verificati manualmente.

Autore: Otto | Comunità: AI Tinkerers | Repo: https://github.com/OttoyRocky/phantom-brain

Per la versione in spagnolo, vedere README.es.md