Torna agli aggiornamenti
New releaseJul 29, 2026

BoxPwnr v0.4.0

Un framework modulare per il benchmarking di LLM e strategie agentiche su sfide di sicurezza in HackTheBox, TryHackMe, PortSwigger Labs, Cybench, picoCTF e altro.

Condividi

BoxPwnr

Un esperimento divertente per vedere fin dove i Large Language Models (LLM) possono arrivare nel risolvere autonomamente sfide CTF e laboratori di sicurezza. È iniziato con HackTheBox e ora copre molte piattaforme e solver agenziali.

BoxPwnr fornisce un sistema plug and play che può essere utilizzato per testare le prestazioni di diverse architetture agenziali: --solver [claude_code, codex, cursor-cli, grok, kiro_cli, external, single_loop_xmltag, single_loop, single_loop_compactation, hacksynth].

Piattaforme supportate: --platform [htb, htb_ctf, htb_challenges, portswigger, ctfd, local, xbow, hackbench, cybergym, exploitbench, picoctf, tryhackme, levelupctf, argus]

Consulta Platform Implementations per la documentazione dettagliata su ogni piattaforma supportata.

Tracce e Benchmark

Tutte le tracce di risoluzione sono disponibili in BoxPwnr Traces & Benchmarks. Ogni traccia include i log completi delle conversazioni che mostrano il ragionamento dell'LLM, i comandi eseguiti e gli output ricevuti. Puoi riprodurre qualsiasi traccia in un visualizzatore web interattivo per vedere esattamente come la macchina è stata risolta passo dopo passo.

🔬 BoxPwnr Traces & Benchmarks

Total Challenges Challenges Solved Total Traces Platforms

PiattaformaRisolteCompletamentoTracce
HTB Starting Point25/25100.0%770
HTB Labs268/52651.0%783
HTB Challenges324/81839.6%732
PortSwigger Labs163/27060.4%377
XBOW102/10498.1%525
Cybench40/40100.0%2165
CyberGym476/150731.6%977
picoCTF502/50399.8%1215
TryHackMe213/47744.8%905
HackBench11/1668.8%27
ExploitBench2/424.8%58
LevelUpCTF50/25419.7%146
Argus47/6078.3%1026
BSidesSF CTF 202643/5184.3%76
Cloud Village CTF 202612/2060.0%30
Neurogrid CTF: The ultimate AI security showdown17/3647.2%197

Come Funziona

BoxPwnr utilizza LLM (o agenti CLI come Claude Code, Codex, Grok o Cursor) per risolvere autonomamente obiettivi CTF/lab attraverso un processo iterativo:

  1. Ambiente: di default, i comandi vengono eseguiti in un container Docker con Kali Linux (--executor docker)
  • Il container viene creato automaticamente al primo avvio (richiede ~10 minuti)
  • La connessione VPN viene stabilita automaticamente quando la piattaforma lo richiede
  1. Ciclo di esecuzione (solver single_loop_* di default):
  • L'LLM riceve un system prompt dettagliato che definisce il suo compito e i vincoli
  • L'LLM suggerisce il comando successivo in base agli output precedenti
  • Il comando viene eseguito nell'executor scelto
  • L'output viene restituito all'LLM per l'analisi
  • Il processo si ripete finché non viene trovata la flag (o soddisfatti i criteri di successo della piattaforma)
  • I solver basati su CLI (claude_code, codex, grok, cursor-cli, kiro_cli) eseguono il proprio ciclo agente e trasmettono i risultati a BoxPwnr
  1. Automazione dei comandi:
  • Agli agenti viene indicato di fornire comandi completamente automatizzati senza interazione manuale
  • I comandi dovrebbero includere timeout adeguati e gestire i ritardi del servizio
  1. Risultati:
  • La conversazione e i comandi vengono salvati come tracce per analisi/riproduzione
  • Può essere generato un riepilogo quando viene trovata una flag
  • Vengono registrate le statistiche di utilizzo (token, costi, turni)

Utilizzo

Prerequisiti

  1. Clona il repository con i sottomoduli ```bash git clone --recurse-submodules https://github.com/0ca/BoxPwnr cd BoxPwnr

    Install uv if you haven't already

    curl -LsSf https://astral.sh/uv/install.sh | sh

    Sync dependencies (creates .venv)

    uv sync

2. Docker
- BoxPwnr richiede che Docker sia installato e in esecuzione
- Le istruzioni di installazione sono disponibili all'indirizzo: [https://docs.docker.com/get-docker/](https://docs.docker.com/get-docker/)

### Eseguire BoxPwnr```bash
uv run boxpwnr --platform htb --target meow [options]

Al primo avvio, ti verranno richieste le chiavi API necessarie. Le chiavi vengono salvate in .env per un uso futuro. I solver CLI (Claude Code, Codex, Grok, Cursor, Kiro) usano la propria autenticazione tramite abbonamento invece delle chiavi API (o in aggiunta a esse).

Opzioni della riga di comando

Opzioni principali

  • --platform: Piattaforma da utilizzare (htb, htb_ctf, htb_challenges, portswigger, ctfd, local, xbow, hackbench, cybench, cybergym, exploitbench, picoctf, tryhackme, levelupctf, argus)
  • --target: Nome del target (ad es., meow per una macchina HTB, "SQL injection UNION attack" per un lab PortSwigger, o XBEN-060-24 per il benchmark XBOW)
  • --debug: Abilita la registrazione dettagliata (mostra nomi e descrizioni degli strumenti)
  • --debug-langchain: Abilita la modalità di debug di LangChain (mostra richieste HTTP complete con schemi degli strumenti, trace LangChain e payload API grezzi - molto verboso)
  • --max-turns: Numero massimo di turni prima di fermarsi (ad es., --max-turns 10)
  • --max-cost: Costo massimo in USD prima di fermarsi (ad es., --max-cost 2.0)
  • --max-time: Tempo massimo in minuti per tentativo (ad es., --max-time 60)
  • --attempts: Numero di tentativi per risolvere il target (ad es., --attempts 5 per benchmark pass@5)
  • --default-execution-timeout: Timeout predefinito per l'esecuzione dei comandi in secondi (predefinito: 30)
  • --max-execution-timeout: Timeout massimo per l'esecuzione dei comandi in secondi (predefinito: 300)
  • --custom-instructions: Ulteriori istruzioni personalizzate da aggiungere al prompt di sistema

Piattaforme

  • --keep-target: Mantieni il target (macchina/lab) in esecuzione dopo il completamento (utile per un follow-up manuale)

Analisi e creazione report

  • --analyze-attempt: Analizza i tentativi falliti utilizzando TraceAnalyzer dopo il completamento
  • --generate-summary: Genera un riepilogo della soluzione dopo il completamento
  • --generate-progress: Genera un file di handoff dello stato di avanzamento (progress.md) per tentativi falliti/interrotti. Questo file può essere utilizzato per riprendere il tentativo in un secondo momento.
  • --resume-from: Percorso di un file progress.md di un tentativo precedente. Il contenuto verrà iniettato nel prompt di sistema per continuare da dove il tentativo precedente si era interrotto.
  • --generate-report: Genera un nuovo report da una directory di trace esistente

Selezione del solver LLM e del modello

  • --solver: Solver LLM da utilizzare (claude_code, codex, cursor-cli, grok, kiro_cli, external, single_loop_xmltag, single_loop, single_loop_compactation, hacksynth)
  • --model: Modello AI da usare (predefinito: openrouter/openai/gpt-oss-120b). I modelli supportati includono:
    • Modelli Claude: usa il nome esatto del modello API (ad es., claude-sonnet-4-0, claude-opus-4-0, claude-haiku-4-5-20251001)
    • Modelli OpenAI: gpt-5, gpt-5-nano, gpt-5-mini
    • Altri modelli: deepseek-reasoner, grok-4, gemini-3-flash-preview
    • Modelli OpenRouter: openrouter/company/model (ad es., openrouter/openrouter/free, openrouter/openai/gpt-oss-120b, openrouter/x-ai/grok-4-fast, openrouter/moonshotai/kimi-k2.5)
    • NVIDIA NIM: nvidia/company/model (ad es., nvidia/moonshotai/kimi-k2.6) tramite integrate.api.nvidia.com
    • NVIDIA playground (senza chiave API; Playwright): nvidia-web/company/model (ad es., nvidia-web/moonshotai/kimi-k2.6)
    • Modelli Z.AI: z-ai/model-name (ad es., z-ai/glm-5, z-ai/glm-5.2) per i modelli GLM di Zhipu AI
    • Modelli gratuiti Kilo: kilo/model-name (ad es., kilo/z-ai/glm-5) tramite il gateway Kilo
    • Modelli Kimi: kimi/model-name (ad es., kimi/kimi-k2.5, kimi/kimi-k2.7) per l'abbonamento a Kimi Code
    • Modelli gratuiti Cline: cline/minimax/minimax-m2.5, cline/moonshotai/kimi-k2.5 (richiede cline auth, vedi sotto)
    • Ollama Cloud: ollama-cloud/model-name (ad es., ollama-cloud/minimax-m3:cloud)
    • Ollama locale: ollama:model-name
  • --reasoning-effort: Livello di sforzo di ragionamento per modelli in grado di ragionare (minimal, low, medium, high). Si applica solo ai modelli che supportano il ragionamento come gpt-5, o4-mini, grok-4. Il valore predefinito è medium per i modelli con capacità di ragionamento.

Opzioni del solver esterno

Il solver external consente a BoxPwnr di delegare a qualsiasi strumento esterno (Claude Code, Aider, script personalizzati, ecc.):

  • --external-timeout: Timeout per il sottoprocesso del solver esterno in secondi (predefinito: 3600)
  • Comando dopo --: il comando esterno da eseguire (ad es., -- claude -p "$BOXPWNR_PROMPT")

Variabili d'ambiente disponibili per gli strumenti esterni:

  • BOXPWNR_PROMPT: Prompt di sistema completo con le informazioni sul target
  • BOXPWNR_TARGET_IP: Informazioni di connessione del target (IP/hostname)
  • BOXPWNR_CONTAINER: Nome del container Docker (utile per scenari VPN)

Esecutori

BoxPwnr supporta diversi ambienti per l'esecuzione dei comandi tramite --executor:

  • docker (predefinito): Esegue i comandi all'interno di un container Docker Kali Linux isolato che BoxPwnr crea e gestisce automaticamente. Questa è l'opzione consigliata per la maggior parte delle piattaforme e dei casi d'uso.
  • ssh: Esegue i comandi su un host remoto tramite SSH. Utile per configurazioni di rete personalizzate o quando si opera sulla propria infrastruttura. Richiede --ssh-host (e opzionalmente --ssh-username, --ssh-key-path, --ssh-port).
  • platform: Instrada i comandi tramite l'attackbox/terminale della piattaforma (WebSocket). Questo è obbligatorio quando si usa --platform levelupctf.

Opzioni correlate:

  • --keep-container: Mantieni il container Docker in esecuzione dopo il completamento (accelera i tentativi successivi).
  • --architecture: Forza un'architettura specifica del container (amd64 è utile su Apple Silicon).
  • --image: Usa un'immagine Docker personalizzata invece dell'immagine Kali integrata.

Opzioni specifiche per piattaforma

  • Opzioni HTB CTF:
    • --ctf-id: ID dell'evento CTF (richiesto quando si usa --platform htb_ctf)
  • Opzioni CTFd:
    • --ctfd-url: URL dell'istanza CTFd (richiesto quando si usa --platform ctfd)
  • Opzioni ExploitBench:
    • --exploitbench-config: Nome della configurazione del benchmark (predefinito: v8)
    • --exploitbench-success-cap: Capability che conta come successo (predefinito: ace)
    • --exploitbench-seed: Seed dell'episodio (predefinito: 1)

Esempi```bash

Regular use (container stops after execution)

uv run boxpwnr --platform htb --target meow --debug

Development mode (keeps container running for faster subsequent runs)

uv run boxpwnr --platform htb --target meow --debug --keep-container

Run on AMD64 architecture (useful for x86 compatibility on ARM systems like M1/M2 Macs)

uv run boxpwnr --platform htb --target meow --architecture amd64

Limit the number of turns

uv run boxpwnr --platform htb --target meow --max-turns 10

Limit the maximum cost

uv run boxpwnr --platform htb --target meow --max-cost 1.5

Run with multiple attempts for pass@5 benchmarks

uv run boxpwnr --platform htb --target meow --attempts 5

Use a specific model

uv run boxpwnr --platform htb --target meow --model claude-sonnet-4-0

Use Claude Haiku 4.5 (fast, cost-effective, and intelligent)

uv run boxpwnr --platform htb --target meow --model claude-haiku-4-5-20251001 --max-cost 0.5

Use GPT-5-mini (fast and cost-effective)

uv run boxpwnr --platform htb --target meow --model gpt-5-mini --max-cost 1.0

Use Grok-4 (advanced reasoning model)

uv run boxpwnr --platform htb --target meow --model grok-4 --max-cost 2.0

Use OpenRouter free tier (auto-routing)

uv run boxpwnr --platform htb --target meow --model openrouter/openrouter/free --max-cost 0.5

Use gpt-oss-120b via OpenRouter (open-weight 117B MoE model with reasoning)

uv run boxpwnr --platform htb --target meow --model openrouter/openai/gpt-oss-120b --max-cost 1.0

Use Kimi K2.5 via OpenRouter (Moonshot AI's reasoning model)

uv run boxpwnr --platform htb --target meow --model openrouter/moonshotai/kimi-k2.5 --max-cost 1.0

Use Cline free model (requires: npm install -g cline && cline auth)

uv run boxpwnr --platform htb --target meow --model cline/minimax/minimax-m2.5

Use Z.AI GLM-5 (Zhipu AI reasoning model)

uv run boxpwnr --platform htb --target meow --model z-ai/glm-5 --max-cost 1.0

Use Kilo free model (GLM-5 via Kilo gateway)

uv run boxpwnr --platform htb --target meow --model kilo/z-ai/glm-5

Use Kimi K2.5 directly (requires Kimi Code subscription)

uv run boxpwnr --platform htb --target meow --model kimi/kimi-k2.5 --max-cost 1.0

Use OpenCode free model (no authentication required)

uv run boxpwnr --platform htb --target meow --model opencode/big-pickle --max-cost 0.5

Use Claude Code solver (use CC as agent)

uv run boxpwnr --platform htb --target meow --solver claude_code --model claude-sonnet-4-0 --max-cost 2.0

Use Codex CLI solver (OpenAI Codex Max subscription)

uv run boxpwnr --platform htb --target meow --solver codex --model gpt-5.3-codex --max-time 60

Use Grok CLI solver (xAI subscription auth)

uv run boxpwnr --platform cybench --target "[Very Easy] Dynastic" --solver grok --max-time 60

Use Cursor CLI solver (Cursor Agent / subscription auth, Docker required)

uv run boxpwnr --platform htb --target meow --solver cursor-cli --model composer-2.5 --max-time 60

Use Kiro CLI solver

uv run boxpwnr --platform htb --target meow --solver kiro_cli --max-time 60

Use HackSynth solver (autonomous CTF agent with planner-executor-summarizer architecture)

uv run boxpwnr --platform htb --target meow --solver hacksynth --model gpt-5 --max-cost 1.0

Use single_loop_compactation solver for long-running traces that may exceed context limits

uv run boxpwnr --platform htb --target meow --solver single_loop_compactation --model gpt-5 --max-turns 100

Customize compaction behavior

uv run boxpwnr --platform htb --target meow --solver single_loop_compactation --compaction-threshold 0.70 --preserve-last-turns 15

Use NVIDIA NIM (API key) or nvidia-web playground (no API key)

uv run boxpwnr --platform htb --target meow --model nvidia/moonshotai/kimi-k2.6 --max-cost 1.0 uv run boxpwnr --platform htb --target meow --model nvidia-web/moonshotai/kimi-k2.6 --max-time 60

Generate a new report from existing attempt

uv run boxpwnr --generate-report machines/meow/traces/20250129_180409

Run an HTB challenge (app.hackthebox.com/challenges)

uv run boxpwnr --platform htb_challenges --target "Flag Command"

Run a CTF challenge

uv run boxpwnr --platform htb_ctf --ctf-id 1234 --target "Web Challenge"

Run a CTFd challenge

uv run boxpwnr --platform ctfd --ctfd-url https://ctf.example.com --target "Crypto 101"

Run with custom instructions

uv run boxpwnr --platform htb --target meow --custom-instructions "Focus on privilege escalation techniques and explain your steps in detail"

Generate a progress file for a failed attempt (can be resumed later)

uv run boxpwnr --platform htb --target meow --generate-progress --max-turns 20

Resume from a previous attempt using the generated progress file

uv run boxpwnr --platform htb --target meow --resume-from targets/htb/meow/traces/20250127_120000/progress.md --max-turns 30

Run XBOW benchmark (automatically clones benchmarks on first use)

uv run boxpwnr --platform xbow --target XBEN-060-24 --model gpt-5 --max-turns 30

List all available XBOW benchmarks

uv run boxpwnr --platform xbow --list

Run Cybench challenge (automatically clones repository on first use)

You can use either the short name or full path

uv run boxpwnr --platform cybench --target "[Very Easy] Dynastic" --model gpt-5 --max-cost 2.0

Or with full path:

uv run boxpwnr --platform cybench --target "benchmark/hackthebox/cyber-apocalypse-2024/crypto/[Very Easy] Dynastic" --model gpt-5 --max-cost 2.0

List all available Cybench challenges (40 professional CTF tasks)

uv run boxpwnr --platform cybench --list

Run ExploitBench (MCP grading; Grok works well here)

uv run boxpwnr --platform exploitbench --target sample-stack-bof --solver grok --exploitbench-success-cap ace --max-time 60 uv run boxpwnr --platform exploitbench --list

Run Argus challenge (Dockerized web vuln benchmarks; targets look like APEX-...)

uv run boxpwnr --platform argus --list uv run boxpwnr --platform argus --target APEX-001 --model gpt-5 --max-cost 1.0

Run CyberGym task (PoC that crashes the vulnerable build; IDs look like arvo:10013 or oss-fuzz:42535201)

uv run boxpwnr --platform cybergym --list uv run boxpwnr --platform cybergym --target arvo:10013 --model gpt-5 --max-cost 2.0

Use external solver with Claude Code (note: wrap in bash -c with single quotes)

uv run boxpwnr --platform htb --target meow --solver external -- bash -c 'claude --dangerously-skip-permissions -p "$BOXPWNR_PROMPT"'

Use external solver with OpenAI Codex CLI

uv run boxpwnr --platform htb --target meow --solver external -- bash -c 'codex --yolo "$BOXPWNR_PROMPT"'

Use external solver with custom timeout (2 hours)

uv run boxpwnr --platform htb --target meow --solver external --external-timeout 7200 -- bash -c 'claude --dangerously-skip-permissions -p "$BOXPWNR_PROMPT"'

Use external solver inside Docker container (for VPN scenarios)

When the target requires VPN, run the external tool inside BoxPwnr's Docker container.

IS_SANDBOX=1 allows --dangerously-skip-permissions to work as root.

uv run boxpwnr --platform htb --target meow --solver external --
bash -c 'docker exec -e IS_SANDBOX=1 -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" "$BOXPWNR_CONTAINER" claude --dangerously-skip-permissions -p "$BOXPWNR_PROMPT"'

## Perché HackTheBox?

Le macchine HackTheBox offrono un eccellente terreno di test end-to-end per valutare i sistemi di intelligenza artificiale, poiché richiedono:

- Capacità di ragionamento complesse
- Pensiero creativo "fuori dagli schemi"
- Comprensione di vari concetti di sicurezza
- Capacità di concatenare più passaggi tra loro
- Competenze dinamiche di problem-solving

## Perché adesso? *(scritto il 26 gennaio 2025)*

Con i recenti progressi nella tecnologia LLM:

- I modelli stanno diventando sempre più sofisticati nelle loro capacità di ragionamento
- Il costo di esecuzione di questi modelli sta diminuendo (vedi DeepSeek R1 Zero)
- La loro capacità di comprendere e generare codice sta migliorando
- Stanno migliorando nel mantenere il contesto e nel risolvere problemi multi-step

Credo che nei prossimi anni gli LLM avranno la capacità di risolvere autonomamente la maggior parte delle macchine HTB, segnando una tappa fondamentale nelle capacità di test di sicurezza e di problem-solving dell'IA.

## Sviluppo

### Testing

BoxPwnr supporta l'esecuzione locale dei workflow di GitHub Actions utilizzando `[act](https://github.com/nektos/act)`, che simula l'ambiente CI esatto prima di eseguire il push su GitHub:```bash
# Install act (macOS)
brew install act

# Run CI workflows locally
make ci-test           # Run main test workflow
make ci-integration    # Run integration tests (slow - downloads Python each time)
make ci-docker         # Run docker build test
make ci-all            # Run all workflows

Disclaimer

Questo progetto è solo a scopo di ricerca e didattico. Segui sempre i termini di servizio e le linee guida etiche di ciascuna piattaforma quando usi questo strumento.

Leggi di più

Categorie

Escalation di PrivilegiRicognizioneFramework di ExploitGenerazione di PayloadAnalisi delle VulnerabilitàSicurezza WebCTFPenetration TestingApprendimento e FormazioneSicurezza dell'IALab e Pratica