bash CLI trainer — 30 livelli da ls a escalation dei privilegi
# cmdchamp
Addestratore CLI per Bash — 30 livelli da `ls` all'escalation dei privilegi.
Ogni domanda ti chiede di digitare un comando reale — ricevi un feedback immediato e vai avanti. Se sbagli, non ti mostra solo la risposta: mostra cosa ha stampato IL TUO comando rispetto a ciò che era richiesto e, per una pipeline, il conteggio delle righe in ogni fase, così puoi vedere il punto in cui si è interrotta. Per le domande con corrispondenza testuale, indica la risposta accettata a cui la tua era più vicina e il flag esatto che hai tralasciato. Se la risolvi nel modo lungo, ti mostra il modo breve — `cat f | grep -c X` ti fa guadagnare un `Shorter: grep -c X f`, attivato sia per un minor numero di fasi della pipeline sia per un minor numero di caratteri, perché il processo che hai risparmiato è la lezione. Molte domande vengono eseguite su file reali nella sandbox e tutte accettano più sintassi valide (`sort -u` o `sort | uniq`). Il tasto Tab attiva la manpage quando ti serve un riferimento — pagine condensate per ogni comando eseguito dalla risposta, più la sintassi shell su cui si basa (`x=$(cmd)`, `${var:-default}`, `${path##*/}`), così nulla in una domanda è lasciato alla tua immaginazione. L'ordine viene randomizzato a ogni esecuzione, così non puoi memorizzarlo. La padronanza tiene traccia di ciò che sai: rispondi correttamente due volte a una domanda per padroneggiarla, sbagliala e viene declassata così che ricompaia prima. Una serie di 5 risposte corrette attiva la fire mode — un banner che resta attivo finché non sbagli.
Ogni livello termina con un boss round — niente manpage, timer di 30s, 4/5 per passare. Se fallisci, puoi riprovare subito il boss o tornare alla pratica. Supera tutti e 30 e si sblocca la **challenge mode** — il percorso finale: catene di comandi multipli che compongono gli strumenti di tutto il gioco in un'unica pipeline. 30s ciascuna, una sola vita, niente manpage, il tuo punteggio migliore è il record. Ogni catena viene valutata sul suo output reale nella sandbox, quindi *qualsiasi* pipeline corretta passa. Ogni esecuzione crea anche una **sandbox randomizzata nuova** — IP, conteggi, host e dati di log diversi — e attinge da oltre 50 modelli di catena con delimitatori, ordine di ordinamento e aggregati variabili, così l'IP più trafficato, l'URL più visitato, il conteggio più alto non sono mai gli stessi due volte. La prima esecuzione include un breve tutorial e un test di posizionamento che ti permette di saltare i livelli che già conosci.
Con [bubblewrap](https://github.com/containers/bubblewrap), i comandi vengono eseguiti in un vero filesystem in sandbox e vengono valutati sul loro output effettivo. La macchina all'interno è sintetica — utente `sandbox`, host `sandbox`, il suo `/etc/passwd` e la sua riga di comando del kernel — quindi nulla di ciò che digiti può stampare a schermo il tuo vero nome utente, il nome della macchina o la disposizione del disco, e `id`, `whoami` e `hostname` rispondono allo stesso modo ovunque. Questo ora raggiunge anche il livello forense: il livello 28 ti consegna un vero binario di esempio (`samples/target.bin`) e valuta se hai effettivamente estratto la flag, il dominio di esfiltrazione e la chiave API trapelata — lo stesso per le domande `jq` su JSON reale. Il percorso finale compone queste estrazioni in catene a tempo. Anche i livelli 24-25 ora vengono eseguiti davvero: un piccolo servizio HTTP si avvia su `localhost:8080` all'interno del namespace di rete della sandbox mentre la tua risposta viene eseguita, con tre porte in ascolto, così `curl`, `jq` su HTTP, `ss` e `nmap` vengono valutati su ciò che hanno effettivamente restituito. Nulla è esposto alla tua macchina — il namespace blocca comunque ogni connessione in uscita e la porta è invisibile dall'esterno. Solo gli strumenti che non possono davvero girare in una sandbox — wifi/RF, cattura live e forense su memoria/disco di grandi dimensioni — restano a corrispondenza testuale. I livelli di ricerca (16-17) accettano sia la sintassi `rg`/`fd` sia `grep`/`find`. L'editing di riga Vi è integrato — movimenti, operatori, conteggi, registri, undo e modalità visuale (`v`/`V`, `o` per scambiare le estremità), con `?` per la mappa completa.
## Installazione
**Arch (AUR):**
```bash
paru -S cmdchamp # oppure: yay -S cmdchamp
```
**Ovunque (file singolo):**
```bash
mkdir -p ~/.local/bin && curl -sL https://raw.githubusercontent.com/mellen9999/cmdchamp/main/cmdchamp -o ~/.local/bin/cmdchamp && chmod +x ~/.local/bin/cmdchamp
```
Aggiungi `~/.local/bin` al PATH se necessario: `echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc`
**Oppure clona:**
```bash
git clone https://github.com/mellen9999/cmdchamp.git
cd cmdchamp && make install
```
**Richiede:** bash 4.4+, coreutils, awk
**macOS:** Include bash 3.2 — installa prima bash 4.4+: `brew install bash`
**Opzionale:** [bubblewrap](https://github.com/containers/bubblewrap) (`bwrap`) per la modalità sandbox (solo Linux) — la maggior parte delle distribuzioni desktop lo include. Senza, le risposte sono solo a corrispondenza testuale
**Opzionale:** `python3` — serve il servizio HTTP localhost della sandbox, così le domande `live api` / `live box` dei livelli 24-25 vengono valutate su output reale. Senza, quelle domande ripiegano sulla corrispondenza testuale; nulla altro cambia
**Accessibilità:** Rispetta `NO_COLOR` e `TERM=dumb`. Il layout si adatta a `COLUMNS` / `tput cols`. Le barre di padronanza portano sia colore sia un simbolo `✓` / `~` / `x` — leggibili anche senza colore.
**Terminali:** Funziona su veri terminali seriali, non solo emulatori. cmdchamp verifica cosa il terminale può effettivamente visualizzare e sceglie uno dei tre livelli di rendering — unicode, disegno di linee DEC ACS o ASCII puro — così i riquadri restano intatti su un VT100/VT220/VT320/VT420 o Wyse. Su uno schermo monocromatico, le distinzioni di colore vengono ri-codificate come grassetto/inverso. Forza un livello con `CMDCHAMP_ASCII=1` o `CMDCHAMP_UNICODE=1`. `./test_terminals.sh` lo verifica.
## Utilizzo
```bash
cmdchamp # Avvia il menu del gioco
cmdchamp explain 'CMD' # Spiega qualsiasi comando - ogni flag, più la sintassi shell circostante
cmdchamp autopsy # Legge la tua cronologia shell e la mappa sul programma
cmdchamp daily # Gioca la sfida giornaliera di oggi (stessa esecuzione per tutti)
cmdchamp daily 2026-02-16 # Ripeti l'esecuzione di un giorno specifico (sfida un amico)
cmdchamp play # Sandbox di gioco libero: digita qualsiasi comando, guardalo eseguire
cmdchamp --no-sandbox # Disabilita la sandbox (solo corrispondenza testuale)
cmdchamp reset # Cancella tutti i progressi
cmdchamp test # Esegue i self-test
cmdchamp version # Stampa la versione
cmdchamp help # Mostra l'aiuto
```
`cmdchamp explain` (o `cmdchamp x`) è il pannello Tab come strumento autonomo: pagine scritte a mano per ~300 comandi più la sintassi shell circostante, offline, senza rete, senza dipendenze. Accetta un comando tra virgolette o le parole singole e legge da stdin quando non riceve nessuno dei due — quindi `history | tail -1 | cmdchamp x` spiega ciò che hai appena eseguito. Esce con 0 quando conosce il comando, 1 quando non lo conosce.
`cmdchamp autopsy` legge la tua cronologia shell — `$HISTFILE`, poi `~/.bash_history`, poi `~/.zsh_history`, o un file che nomini tu, o `-` per stdin — e la mappa sui 30 livelli: ciò a cui ricorri davvero, le abitudini da abbandonare con il tuo conteggio accanto a ciascuna (`cat` in `grep`, `find` in `xargs` senza `-print0`, `chmod 777`, `curl | sh`), quanti dei comandi che il gioco insegna hai mai eseguito e il primo livello con una lacuna. Stampa **solo modelli e conteggi** — mai una riga, un frammento o un "esempio" dalla tua cronologia, perché una cronologia contiene token e password digitati come argomenti. Nulla lascia la macchina e non esiste un flag per fargli fare eco alla tua cronologia.
Il menu contiene continua, nuova partita, scenari, challenge, daily, pratica, statistiche, opzioni, aiuto ed esci su hotkey fisse `1`-`9` e `0`. Una riga non ancora sbloccata è attenuata anziché nascosta, così la cifra accanto a un'etichetta non si sposta mai mentre avanzi. `j`/`k` o le frecce muovono, Invio seleziona e `q` (o Esc) esce. Il parco giochi si trova in cima all'elenco **Scenari** — è l'unica voce che non è mai bloccata. **Aiuto** è il riferimento, tre pagine: ogni tasto, cosa costa e cosa sblocca ogni modalità, come funzionano punteggio e decadimento, cosa significano i segni nelle Statistiche, come viene giudicata una risposta e ogni variabile d'ambiente. Il tutorial della prima esecuzione è ancora a un tasto di distanza sull'ultima pagina.
**Daily** (post-ROOT) è una sfida a tempo con seed basato sulla data — il seed guida sia le catene sia la sandbox randomizzata, così tutti ovunque ricevono domande *e* dati byte-identici quel giorno, un tentativo valutato, una serie di giorni consecutivi e un punteggio copiabile da condividere. **Pratica** esercita qualsiasi livello raggiunto (mostrato con la sua % di padronanza) con suggerimenti e senza timer, senza toccare i tuoi progressi principali. **Parco giochi** è una macchina compromessa che smonti con una shell reale: qualcuno è entrato, l'ha usata, poi ha provato a ripulire, e ogni mossa ha lasciato un segno sul disco. I comandi vengono eseguiti davvero nella sandbox e nulla viene valutato. Fino a 8 token `flag{...}` sono piantati nell'albero (altri si sbloccano man mano che superi i livelli), `map` dispone l'intrusione fase per fase e segna dove ti trovi, `learn` è il programma di sicurezza in 8 moduli dietro di esso, `hint` scende di un livello più in profondità ogni volta che chiedi, e Tab spiega ciò che hai digitato. L'intestazione nomina sempre la fase che stai cercando e i file che ha lasciato, così non resti mai a fissare un prompt senza sapere dove puntare un comando — e se passano sei comandi senza trovare nulla, il primo suggerimento arriva da solo.
## Statistiche
Due pagine. La prima è le trenta barre dei livelli — quanto sei arrivato lontano. La seconda è la stessa padronanza proiettata sui **comandi**, dal più debole al più forte, perché un livello è un contenitore di gran lunga troppo grossolano per esercitarsi: solo il livello 13 insegna `cp`, `mv`, `ln`, `chmod`, ACL, `du`, `tar` e `diff`, e una barra rossa non può dire quale di questi continui a sbagliare. Vengono contati solo i livelli che hai raggiunto e la griglia è limitata a uno schermo — una lista di lavoro che devi scorrere non è una lista di lavoro. Sotto, i tre comandi più deboli sono nominati con il livello che insegna ciascuno, così la pagina finisce dove inizia la Pratica — i nomi dei livelli sono tematici, e `xargs 0/4` è un vicolo cieco se devi indovinare che Batch Ops è dove si trova.
## Livelli
| # | Nome | Focus |
|---|------|-------|
| | **Fondamenta** | |
| 1 | Primi Passi | pwd, ls, echo, cd, mkdir |
| 2 | Nozioni sui File | cp, mv |
| 3 | Salva il Tuo Lavoro | >, >>, tee |
| 4 | Leggere i File | cat, head, tail, less |
| 5 | Pipe di Base | pipe, grep, wc, sort, uniq |
| 6 | Input e Here-Strings | <, <<<, tr, cut, rev, bc |
| 7 | Gestione degli Errori | 2>, 2>&1, &>, /dev/null |
| 8 | Porte Logiche | &&, \|\| |
| 9 | Variabili | `$VAR`, assegnazione, espansione |
| 10 | Variabili Speciali | `$$`, `$?`, `$!`, `$#`, `$@`, `$0` |
| 11 | Controllo dei Job | bg, fg, jobs, &, Ctrl+Z, nice, ulimit |
| 12 | Condizioni di Test | -f, -d, -z, -n, -eq, -lt |
| 13 | Strumenti File Principali | cp, mv, ln, chmod, ACL, du, tar, diff |
| 14 | Amministrazione di Sistema | ping, df, free, ss, systemctl, ip, sysctl, lsblk, getent |
| 15 | Multiplexer | tmux: sessioni, finestre, pannelli |
| 16 | Ricerca Testuale | grep, ripgrep, regex |
| 17 | Trovare File | find, fd, per nome/dimensione/tempo/tipo |
| 18 | Elaborazione Dati | sort, uniq, cut, awk, tr, comm, join, numfmt |
| 19 | Stringhe e Array | espansione dei parametri, array |
| 20 | Flusso di Controllo | if/else, cicli, case, funzioni |
| 21 | Operazioni Batch | find -exec, xargs, sed -i, crontab |
| 22 | Regex Avanzate | lookahead, sed, awk |
| | **DevOps e Sicurezza** | |
| 23 | Git | rami, remote, rebasing, stashing, bisect |
| 24 | Strumenti di Rete | tshark, curl, jq, tunnel ssh, openssl, SMB, un endpoint HTTP live |
| 25 | Scansione di Rete | nmap, rilevamento servizi, script, un target live |
| 26 | WiFi e RF | aircrack-ng, netcat, tcpdump, ricognizione wireless |
| 27 | Cracking di Hash | hashcat, john, hydra, codifica |
| 28 | Forense | strings, readelf, binwalk, volatility, exiftool |
| 29 | Escalation dei Privilegi | SUID, capabilities, GTFOBins, enumerazione |
| 30 | ROOT | recupero di emergenza, chroot, sopravvivenza offline |
## Scenari
Sfide sandbox multi-fase — lo stato persiste tra le fasi. Disponibili dal menu **Scenari** una volta superato il boss di sblocco, che le elenca in ordine di sblocco sotto il parco giochi. I numeri sotto sono gli id degli scenari, che non cambiano mai.
| # | Nome | Si sblocca a | Fasi |
|---|------|-----------|-------|
| 1 | Blocco dei Permessi | boss L13 | 6 |
| 2 | Archivia e Estrai | boss L13 | 6 |
| 3 | Trova l'Ago | boss L16 | 7 |
| 4 | CSV Disordinato | boss L18 | 4 |
| 5 | L'Incidente | boss L18 | 5 |
| 6 | Il Deploy Rotto | boss L21 | 7 |
| 7 | Emergenza Log | boss L21 | 5 |
| 8 | Chirurgia di Config | boss L21 | 5 |
| 9 | Salvataggio Git | boss L23 | 6 |
| 10 | Refactoring Batch | boss L21 | 6 |
| 11 | Spazzata Forense | boss L22 | 6 |
| 12 | Backup con Wildcard | boss L29 | 4 |
| 13 | Dirottamento PATH | boss L29 | 4 |
Gli scenari 12–13 sono box di exploit: pianti una vera iniezione tar-checkpoint / dirottamento PATH e vieni valutato sull'artefatto che produce (un file appare, un segreto viene esfiltrato). L'*effetto* dell'exploit viene eseguito davvero nella sandbox; il confine dei privilegi è simulato — nulla viene eseguito come vero root.
## Test di posizionamento
Dopo il tutorial della prima esecuzione, ti viene chiesto se vuoi fare il test di posizionamento per saltare avanti. Se accetti, esegue 2 domande per livello, 30s ciascuna, niente manpage. Sbagliane una e quello è il tuo livello di partenza.
## Uova di Pasqua
8 achievement nascosti. La schermata Statistiche mostra quanti ne hai trovati.
## Controlli
| Tasto | Azione |
|-----|--------|
| Invio | Invia la risposta |
| Tab | Attiva/disattiva la manpage |
| Ctrl+d | Esci (riepilogo della sessione) |
| Esc | Modalità normale Vi |
| ? | Tutte le combinazioni di tasti (modalità normale) |
## Dati
I progressi vengono salvati in `${XDG_DATA_HOME:-~/.local/share}/cmdchamp/`.
## Licenza
MIT