`serve` stampa un URL. Aprilo in qualsiasi browser e ottieni un terminale, un file browser e un proxy verso la rete di quella macchina — oppure raggiungi la stessa macchina da un altro terminale con `bitbang connect <url>`, che aggiunge il port forwarding (`-L`) e la copia di file (`bitbang cp`). La connessione è crittografata end-to-end e peer-to-peer; il server `bitba.ng` presenta le due estremità, poi si fa da parte.

`bitbang` è un singolo binario Go statico. Fa parte del [progetto BitBang](https://github.com/richlegrand/bitbang); questo [whitepaper](https://github.com/richlegrand/bitbang/blob/main/whitepaper.md) copre il design in dettaglio.

## Come si confronta

|                                | ngrok                  | Tailscale                      | `bitbang`           |
| ------------------------------ | ---------------------- | ------------------------------ | ------------------- |
| Configurazione prima del primo utilizzo         | Account + authtoken    | Account + login su ogni dispositivo | **Esegui un solo comando** |
| Per condividere qualcosa, esegui    | un web server, più ngrok | il loro client su entrambe le macchine | **`bitbang serve`** |
| Cosa ottiene un browser all'estremità remota | il web server che stavi già eseguendo | niente — richiede il loro client | **un terminale, un file browser e web app sulla rete remota** |
| Percorso dei dati                      | i loro server          | P2P (fallback relay)           | **P2P (fallback relay)** |
| Crittografato end-to-end           | Non di default         | Sì                            | **Sì**             |

## Ricette rapide

**Raggiungi un servizio a casa**

- [Monta il tuo NAS di casa da qualsiasi luogo (SMB)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#mount-your-home-nas-from-anywhere-smb)
- [Guarda la tua libreria multimediale da qualsiasi luogo (Jellyfin)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-your-media-library-from-anywhere-jellyfin)
- [Usa il tuo LLM da qualsiasi luogo (Ollama, Open WebUI)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#use-your-own-llm-from-anywhere-ollama-open-webui)
- [Controlla le tue telecamere di sicurezza (Frigate)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-security-cameras-frigate)
- [Raggiungi la tua domotica senza esporla (Home Assistant)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-your-home-automation-without-exposing-it-home-assistant)
- [Stampa sulla tua stampante di casa (IPP, CUPS)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#print-to-your-home-printer-ipp-cups)

**Accedi a una macchina**

- [Ottieni una shell su una macchina dietro NAT](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-on-a-machine-behind-nat)
- [Ottieni una shell dal tuo telefono](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-from-your-phone)
- [Desktop remoto su una macchina Windows (RDP)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#remote-desktop-into-a-windows-machine-rdp)
- [Raggiungi un desktop Linux o Mac (VNC)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-linux-or-mac-desktop-vnc)
- [SSH verso una macchina senza porte aperte (OpenSSH)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#ssh-to-a-machine-with-no-open-port-openssh)
- [Configura un Raspberry Pi headless](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#set-up-a-headless-raspberry-pi)

**Condividi con qualcun altro**

La condivisione consiste semplicemente nel dare a qualcuno un URL univoco o un codice QR che gli garantisce l'accesso. Le autorizzazioni possono essere personalizzate e impostate per scadere in minuti, ore, ecc.

- [Condividi file senza caricarli da nessuna parte](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#share-files-without-uploading-them-anywhere)
- [Mostra a qualcuno il tuo progetto](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#show-someone-your-project)
- [Dai a qualcuno un accesso che scade](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#give-someone-access-that-expires)
- [Controlla la tua sessione agente dal telefono (Claude Code, tmux)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-agent-session-from-your-phone-claude-code-tmux)
- [Ripara il router di qualcun altro](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#fix-someone-elses-router)

**Sviluppo e dispositivi**

- [Raggiungi un database dalla tua macchina di sviluppo (Postgres, MySQL)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-database-from-your-dev-machine-postgres-mysql)
- [Sincronizza dispositivi che non riescono a trovarsi (Syncthing)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#sync-devices-that-cannot-find-each-other-syncthing)
- [Guarda un robot da un browser (ROS, Foxglove)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-a-robot-from-a-browser-ros-foxglove)

**Tecniche**

- [Cosa espone un listener di forwarding](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#what-a-forwarding-listener-exposes)
- [Consenti ad altre macchine sulla tua LAN di usare un forward](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#let-other-machines-on-your-lan-use-a-forward)
- [Noto per non funzionare](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#known-not-to-work)

## Usare `bitbang`

Ogni connessione ha due estremità: un **listener** (`bitbang serve`, in esecuzione sulla macchina da raggiungere) e un **connector** (un browser, o la CLI `bitbang`, sulla macchina che effettua la connessione). Un singolo URL del listener serve entrambi i tipi di connector.

### Il listener: `bitbang serve````
bitbang serve                    # everything: shell + proxy + files + forward
bitbang serve shell              # just a terminal
bitbang serve files ~/share      # just a directory (-files-upload to allow uploads)
bitbang serve proxy localhost:8080       # just one web app, straight at the URL
bitbang serve proxy a.lan:80,b.lan:80    # ...or several, chosen in the browser
bitbang serve forward 127.0.0.1:22       # just TCP, for `connect -L`

bitbang serve shell files ~/share proxy nas.lan:8096   # any combination

Il comando restituisce il controllo dopo la pubblicazione, quindi `Ctrl-Z`, `bitbang share`, `fg`
funziona anche per un'attività già in corso. L'hosting richiede tmux 3.2+ su Unix o
WSL. I client Windows nativi possono aprire gli URL ma non possono ospitare una condivisione.

Per impostazione predefinita, il comando stampa due URL bearer:

- L'**URL di controllo** può digitare con la stessa autorità della tastiera locale.
  Un solo controllore può connettersi alla volta.
- L'**URL di visualizzazione** è solo di osservazione. L'input viene scartato prima di raggiungere tmux, e
  fino a `--max-viewers` spettatori possono connettersi contemporaneamente (default 16).

`--read-only` omette del tutto la credenziale di controllo. I limiti per spettatori e controllori
vengono mantenuti per l'intera durata di ogni connessione, anche prima che venga aperta una shell.

Le condivisioni restano attive finché non vengono fermate per impostazione predefinita; `--ttl` imposta una durata (ad es. `--ttl 1h`).
Gli URL di condivisione sono effimeri e non vengono mai salvati in `devices.json`. `share stop`,
la scadenza del TTL o la rimozione della sessione sorgente disconnette i peer remoti senza
fermare la sessione sorgente.

Rieseguire `bitbang share` ristampa gli URL della condivisione in esecuzione. Se
passi un flag in disaccordo con ciò che è in esecuzione (ad esempio `--read-only`
contro una condivisione che ha un URL di controllo), lo segnala invece di
restituire i vecchi URL; `bitbang share rotate` sostituisce la condivisione
con una che utilizza i nuovi flag.

Un worker in background viene eseguito in una sessione di gestione tmux staccata `_bbshare_*`,
quindi non c'è alcun demone o file PID da gestire.

La condivisione non modifica alcuna opzione di tmux. Con il default di tmux `window-size latest`, la
finestra segue il client di lettura-scrittura attivo; un singolo spettatore fornisce comunque
l'unica dimensione disponibile. Se `window-size` è stato sovrascritto, `share` lo segnala
ma non modifica la configurazione dell'utente.

### Distribuzione di accesso limitato: `bitbang link`

Un listener, un URL e tutti gli **access link** che ti servono. Ognuno è un
codice separato su quello stesso URL, che concede un sottoinsieme di ciò che il listener offre
e che facoltativamente scade a un'ora fissa:```
bitbang link edit                # add entries in $EDITOR
bitbang link ls                  # what you have handed out
bitbang link rm <label>          # revoke one
bitbang link qr <label>          # its URL and QR code

## Installazione

### Requisiti

- Python 3.8 o superiore
- pip (gestore di pacchetti Python)

### Passaggi di installazione

1. Clona il repository:

```bash
git clone https://github.com/example/tool.git
cd tool

pip install -r requirements.txt

python tool.py --version

pip install -r requirements-optional.txt

python tool.py scan --target example.com

python tool.py scan --target example.com

python tool.py scan --target example.com --verbose

python tool.py scan --target example.com --output results.json

# Configurazione dello strumento
tool:
  timeout: 30
  retries: 3
  user_agent: "Mozilla/5.0"

# Impostazioni di scansione
scan:
  threads: 10
  ports: [80, 443, 8080]
  protocols: ["http", "https"]

sudo python tool.py scan --target example.com

pip install -r requirements.txt

proxy:
  http: "http://proxy.example.com:8080"
  https: "https://proxy.example.com:8080"

`owner` è il codice dell'identità stessa e concede tutto ciò che il listener serve; invia
uno degli altri. La console accetta sia l'etichetta sia il numero accanto
ad essa, quindi `rm 2` e `rm ben` fanno la stessa cosa.

Un `grant` è scritto nelle parole che `serve` accetta, e può solo restringere ciò che il
listener già serve. Ciò significa che un link non è limitato a selezionare capacità:
può nominare una sottodirectory della cartella condivisa, un sottoinsieme delle destinazioni di inoltro, o
un singolo comando per `shell`. Ometti `grant` e il link concede tutto ciò che il listener
fa. Chiedi qualcosa al di fuori della portata del listener e la console lo rifiuta con
lo stesso messaggio che `serve` ti darebbe.

L'etichetta è ciò che identifica un link, non i suoi termini, quindi due persone possono avere link
con grant e scadenza identici e puoi comunque revocarne uno senza toccare
l'altro.

La revoca e la scadenza raggiungono le sessioni già aperte: la connessione si chiude
e al titolare viene detto il motivo, invece di andare in silenzio. E un codice scaduto viene
ritirato piuttosto che messo in pausa -- rinnovare una voce ne genera uno nuovo, quindi l'URL che
hai già inviato resta morto.

### Abbinamento con un codice a 6 cifre

Quando non puoi incollare un URL o scansionare un codice QR, ad esempio quando sei al telefono, o a distanza di urlo, `bitbang serve` stampa anche un breve **codice di abbinamento**. L'altra parte apre `bitba.ng/<code>` (o esegue `bitbang connect <code>`), il suo schermo mostra un secondo numero a 6 cifre, e ti legge *quello* ad alta voce. Lo digiti tu per approvare. Un uomo nel mezzo non può far corrispondere i due numeri, e l'abbinamento salva le credenziali di connessione del dispositivo per la prossima volta, ad es. `bitbang connect nas1`. Se conosci [Magic Wormhole](https://github.com/magic-wormhole/magic-wormhole), la forma è simile -- un codice parlato che introduce in modo sicuro due macchine.
	
![Il server stampa un codice di abbinamento di 5 minuti; l'altra parte lo inserisce su bitba.ng, il suo schermo mostra una sfida a 6 cifre da leggere ad alta voce, e digitandolo di nuovo sulla macchina che serve si approva la connessione](https://assets.kitploit.com/production/public/readmes/47068/a5df368669e25ce461cc712a7c83d5dc41459c94a2f8281992ae695f4543223b.webp)

### Porta il tuo TURN

La maggior parte delle connessioni va direttamente peer-to-peer. Quando entrambe le estremità sono dietro un NAT che
non fa hole-punching, il traffico ha bisogno di un relay, e per impostazione predefinita è il nostro. `-ice-servers`
punta il listener al tuo invece:```
bitbang serve -ice-servers ~/turn.json

## Installazione

```bash
# Clona il repository
git clone https://github.com/example/tool.git

# Entra nella directory
cd tool

# Installa le dipendenze
pip install -r requirements.txt

python tool.py --target example.com --output report.txt

python tool.py --target example.com

python tool.py --target example.com --output report.txt --verbose --threads 20

# config.yaml
target:
  timeout: 30
  retries: 3
  user_agent: "Mozilla/5.0"

scan:
  ports: [80, 443, 8080]
  protocols: ["http", "https"]
  threads: 10

chmod +x tool.py

pip install -r requirements.txt

I'm ready to translate the Kitploit tool content from English to Italian. Please provide chunk 19 of 35.```json
{"iceServers": [{"urls": ["turn:turn.example.net:3478"], "username": "u", "credential": "p"}]}

`-L` inoltra **solo TCP**, come `ssh -L`. `-L` si lega a `127.0.0.1` a meno che non passi
`-g`, che rende la porta inoltrata raggiungibile dalla tua rete locale -- e
chiunque la raggiunga ottiene ciò che il tunnel raggiunge, senza alcuna
credenziale BitBang davanti.

Il listener richiede `bitbang serve forward` o `bitbang serve`. Di default un
link `forward` raggiunge **qualsiasi host:porta che il listener può raggiungere**, non solo
quello che avevi in mente, quindi un link distribuito per un database raggiunge anche il resto
di quella rete. Restringilo nominando ciò che può raggiungere:```
bitbang serve forward db.internal:5432        # this link reaches one service

Linux e macOS. Rileva il tuo sistema operativo e l'architettura (`amd64`, `arm64` e `armv7` su Linux), scarica il binario dall'ultima [release di GitHub](https://github.com/richlegrand/bitbang-cli/releases), verifica il suo SHA-256 rispetto al `checksums.txt` della release e lo installa in `~/.local/bin/bitbang`.

Le build per Windows sono pubblicate come `bitbang-windows-amd64.exe` e
`bitbang-windows-arm64.exe`. Scarica il binario appropriato dalle Release,
rinominalo in `bitbang.exe` e posizionalo nel tuo `PATH`.
**Compila dal sorgente:** vedi [sotto](#building-from-source).

**macOS e Gatekeeper.** Il comando di installazione one-liner sopra non è influenzato: `curl` non
imposta l'attributo `com.apple.quarantine`, quindi il binario che scarica viene eseguito
normalmente. Se invece scarichi `bitbang-darwin-arm64` dalla pagina delle Release
tramite un browser, macOS lo mette in quarantena e rifiuta di aprirlo, perché i binari
delle release non sono notarizzati. Rimuovi la quarantena con uno dei seguenti comandi:```
xattr -d com.apple.quarantine ./bitbang-darwin-arm64

I tag di rilascio non hanno il prefisso `v` (`0.5.0`, non `v0.5.0`).

### Come funziona l'URL di installazione

`bitba.ng/install` è un redirect, non uno script ospitato. La catena:

1. `curl` raggiunge `https://bitba.ng/install`, che reindirizza con un 302 a [`install.sh`](https://github.com/richlegrand/bitbang-cli/blob/HEAD/install.sh) in questo repository (sul branch `main`).
2. Lo script viene eseguito nella tua shell, rileva sistema operativo e architettura, e scarica l'asset binario da `https://github.com/richlegrand/bitbang-cli/releases/latest/download/bitbang-linux-<arch>`.
3. Recupera `checksums.txt` dalla stessa release e verifica lo SHA-256 del binario.
4. Installa in `~/.local/bin` (sovrascrivibile).

Lo script di installazione vive in questo repository, accanto al codice che installa — così puoi esaminarlo insieme al binario, e l'host canonico bitba.ng possiede solo l'URL breve. Chi si auto-ospita può puntare `/install` del proprio host a qualsiasi script distribuisca: la variabile d'ambiente `INSTALL_URL` del server di segnalazione controlla la destinazione del redirect (vuota → 404).

## Riferimento dei comandi

Ogni sottocomando e flag è documentato in **[CLI.md](https://github.com/richlegrand/bitbang-cli/blob/HEAD/CLI.md)**, e `bitbang <comando>
--help` stampa la stessa cosa nel terminale.

## Compilazione dal sorgente

Richiede Go 1.25+. Puro Go, collegato staticamente (`CGO_ENABLED=0`) — compilazione incrociata banale, nessuna dipendenza a runtime.```
go build ./cmd/bitbang/

# cross-compile:
GOOS=linux   GOARCH=arm64        go build -o bitbang-arm64 ./cmd/bitbang/
GOOS=linux   GOARCH=arm GOARM=7  go build -o bitbang-armv7 ./cmd/bitbang/
GOOS=windows GOARCH=amd64        go build -o bitbang.exe   ./cmd/bitbang/
GOOS=darwin  GOARCH=arm64        go build -o bitbang-macos ./cmd/bitbang/

Comandi shell, condivisione file, proxy e client CLI sono supportati su
Windows. Le shell interattive del browser e della CLI usano Windows ConPTY,
inclusi l'eco dell'input del terminale, la modifica delle righe, l'output VT e
gli eventi di ridimensionamento. ConPTY richiede Windows 10 versione 1809 o
Windows Server 2019 o versioni successive.

## Diagrammi

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/d68fcddad62ab84f11a549906a2b5abf2330fb25f39b3c1a1266eac7257a080d.png" alt="bitbang CLI shell e condivisione file" width="760">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/55bb6866c22504a6434e3dee8cb998e747cd73cb9d0bfa5e0bc0ede7b90ce262.png" alt="bitbang operazione proxy CLI" width="720">  
</p>

## Roadmap

Disponibili oggi: **shell, file e proxy**, raggiungibili dal browser o dalla CLI, oltre a **inoltro porte TCP**, copia file in stile scp, **accoppiamento ad-hoc** con una tabella dispositivi salvata, **condivisione terminale** (`bitbang share`) e **link di accesso** (`bitbang link`) che restringono e fanno scadere ciò che un URL concede. Progettate e in arrivo:

- **Bridging seriale** -- pilotare una `/dev/ttyUSB0` remota da una porta virtuale locale (ad es. eseguire Arduino IDE su Internet). È stata aperta una issue [qui](https://github.com/richlegrand/bitbang-cli/issues/3).
- **Desktop remoto** -- schermo su una traccia video WebRTC, tastiera/mouse sul canale dati.

## Licenza

MIT -- vedi [LICENSE](https://github.com/richlegrand/bitbang-cli/blob/HEAD/LICENSE).

## Contributi

Issue e PR benvenuti.

Le ricette sono diverse: vivono nel [cookbook](https://github.com/richlegrand/bitbang/blob/main/cookbook.md),
nel repo [bitbang](https://github.com/richlegrand/bitbang), perché riguardano
ogni progetto piuttosto che questo. Aggiungere una ricetta è una PR lì.

Farla *elencare* è una seconda piccola PR per ogni progetto il cui README dovrebbe
evidenziarla -- l'elenco [Ricette](#recipes) sopra è mantenuto qui a mano. Questo è
voluto: ogni progetto decide quali ricette vale la pena mostrare ai propri
lettori, piuttosto che far crescere ogni README con ogni ricetta.