`serve` gibt eine URL aus. Öffne sie in einem beliebigen Browser und du erhältst ein Terminal, einen Dateibrowser und einen Proxy zum Netzwerk dieser Maschine – oder erreiche dieselbe Maschine von einem anderen Terminal aus mit `bitbang connect <url>`, was Portweiterleitung (`-L`) und Dateikopie (`bitbang cp`) hinzufügt. Die Verbindung ist Ende-zu-Ende-verschlüsselt und Peer-to-Peer; der `bitba.ng`-Server stellt die beiden Enden vor, tritt dann aber beiseite.

`bitbang` ist eine einzelne statische Go-Binary. Es ist Teil des [BitBang-Projekts](https://github.com/richlegrand/bitbang); dieses [Whitepaper](https://github.com/richlegrand/bitbang/blob/main/whitepaper.md) behandelt das Design ausführlich.

## Vergleich

|                                | ngrok                  | Tailscale                      | `bitbang`           |
| ------------------------------ | ---------------------- | ------------------------------ | ------------------- |
| Einrichtung vor der ersten Nutzung | Konto + Authtoken    | Konto + Login auf jedem Gerät | **Einen Befehl ausführen** |
| Zum Teilen führst du aus    | einen Webserver, plus ngrok | ihren Client auf beiden Maschinen | **`bitbang serve`** |
| Was ein Browser am anderen Ende erhält | den Webserver, den du bereits ausgeführt hast | nichts – er benötigt ihren Client | **ein Terminal, einen Dateibrowser und Web-Apps im entfernten Netzwerk** |
| Datenpfad                      | ihre Server          | P2P (Relay-Fallback)           | **P2P (Relay-Fallback)** |
| Ende-zu-Ende-verschlüsselt           | Standardmäßig nicht         | Ja                            | **Ja**             |

## Schnellrezepte

**Erreiche einen Dienst zu Hause**

- [Mounte dein Heim-NAS von überall (SMB)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#mount-your-home-nas-from-anywhere-smb)
- [Schaue deine Mediathek von überall (Jellyfin)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-your-media-library-from-anywhere-jellyfin)
- [Nutze dein eigenes LLM von überall (Ollama, Open WebUI)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#use-your-own-llm-from-anywhere-ollama-open-webui)
- [Prüfe deine Sicherheitskameras (Frigate)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-security-cameras-frigate)
- [Erreiche deine Hausautomation, ohne sie freizugeben (Home Assistant)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-your-home-automation-without-exposing-it-home-assistant)
- [Drucke auf deinen Heimdrucker (IPP, CUPS)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#print-to-your-home-printer-ipp-cups)

**Auf eine Maschine zugreifen**

- [Erhalte eine Shell auf einer Maschine hinter NAT](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-on-a-machine-behind-nat)
- [Erhalte eine Shell von deinem Telefon](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-from-your-phone)
- [Remote-Desktop auf eine Windows-Maschine (RDP)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#remote-desktop-into-a-windows-machine-rdp)
- [Erreiche einen Linux- oder Mac-Desktop (VNC)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-linux-or-mac-desktop-vnc)
- [SSH zu einer Maschine ohne offenen Port (OpenSSH)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#ssh-to-a-machine-with-no-open-port-openssh)
- [Richte einen headless Raspberry Pi ein](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#set-up-a-headless-raspberry-pi)

**Mit jemand anderem teilen**

Teilen bedeutet einfach, jemandem eine eindeutige URL oder einen QR-Code zu geben, der ihm Zugriff gewährt. Berechtigungen können angepasst und so eingestellt werden, dass sie in Minuten, Stunden usw. ablaufen.

- [Teile Dateien, ohne sie irgendwo hochzuladen](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#share-files-without-uploading-them-anywhere)
- [Zeige jemandem dein Projekt](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#show-someone-your-project)
- [Gewähre jemandem Zugriff, der abläuft](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#give-someone-access-that-expires)
- [Prüfe deine Agent-Sitzung von deinem Telefon aus (Claude Code, tmux)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-agent-session-from-your-phone-claude-code-tmux)
- [Repariere den Router von jemand anderem](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#fix-someone-elses-router)

**Entwicklung und Geräte**

- [Erreiche eine Datenbank von deiner Entwicklungsmaschine (Postgres, MySQL)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-database-from-your-dev-machine-postgres-mysql)
- [Synchronisiere Geräte, die sich nicht finden können (Syncthing)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#sync-devices-that-cannot-find-each-other-syncthing)
- [Beobachte einen Roboter aus einem Browser (ROS, Foxglove)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-a-robot-from-a-browser-ros-foxglove)

**Techniken**

- [Was ein Weiterleitungs-Listener freigibt](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#what-a-forwarding-listener-exposes)
- [Lass andere Maschinen in deinem LAN eine Weiterleitung nutzen](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#let-other-machines-on-your-lan-use-a-forward)
- [Bekanntlich nicht funktionierend](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#known-not-to-work)

## `bitbang` verwenden

Jede Verbindung hat zwei Enden: einen **Listener** (`bitbang serve`, läuft auf der Maschine, die erreicht wird) und einen **Connector** (einen Browser oder die `bitbang`-CLI auf der Maschine, die erreicht). Eine Listener-URL bedient beide Arten von Connectoren.

### Der 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

Der Befehl kehrt nach dem Veröffentlichen zurück, sodass `Ctrl-Z`, `bitbang share`, `fg`
für eine bereits laufende Aufgabe funktioniert. Das Hosten erfordert tmux 3.2+ unter Unix oder
WSL. Native Windows-Clients können die URLs öffnen, aber keine Freigabe hosten.

Standardmäßig gibt der Befehl zwei Bearer-URLs aus:

- Die **Control-URL** kann mit derselben Berechtigung wie die lokale Tastatur tippen.
  Es kann sich jeweils ein Controller verbinden.
- Die **View-URL** ist nur zum Ansehen. Eingaben werden verworfen, bevor sie tmux erreichen, und
  bis zu `--max-viewers` Zuschauer können sich gleichzeitig verbinden (Standard: 16).

`--read-only` lässt die Control-Anmeldedaten vollständig weg. Zuschauer- und Controller-
Grenzen gelten für die gesamte Verbindungsdauer, sogar bevor eine Shell geöffnet wird.

Freigaben laufen standardmäßig, bis sie gestoppt werden; `--ttl` legt eine Lebensdauer fest (z. B. `--ttl 1h`).
Freigabe-URLs sind ephemer und werden nie in `devices.json` gespeichert. `share stop`,
TTL-Ablauf oder das Entfernen der Quellsitzung trennt entfernte Peers, ohne
die Quellsitzung zu stoppen.

Das erneute Ausführen von `bitbang share` gibt die URLs der laufenden Freigabe erneut aus. Wenn Sie
ein Flag übergeben, das nicht mit dem übereinstimmt, was läuft (z. B. `--read-only`
gegen eine Freigabe, die eine Control-URL hat), wird dies mitgeteilt, anstatt
die alten URLs zurückzugeben; `bitbang share rotate` ersetzt die Freigabe
durch eine, die die neuen Flags verwendet.

Ein Hintergrund-Worker läuft in einer abgetrennten `_bbshare_*`-tmux-Verwaltungssitzung,
sodass kein Daemon oder keine PID-Datei verwaltet werden muss.

Das Teilen ändert keine tmux-Optionen. Mit tmux' Standard `window-size latest` folgt das
Fenster dem aktiven Lese-Schreib-Client; ein einzelner Zuschauer liefert weiterhin die
einzige verfügbare Größe. Wenn `window-size` überschrieben wurde, meldet `share` dies,
ändert aber nicht die Benutzerkonfiguration.

### Eingeschränkten Zugriff ausgeben: `bitbang link`

Ein Listener, eine URL und so viele **Zugriffslinks**, wie Sie benötigen. Jeder ist ein
separater Code auf derselben URL, der eine Teilmenge dessen gewährt, was der Listener bietet,
und optional zu einem festen Zeitpunkt abläuft:```
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

pip install kitploit-tool

git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt
python setup.py install

kitploit-tool --config config.yaml

server:
  host: 0.0.0.0
  port: 8080
  tls: true
  cert_path: /etc/kitploit/cert.pem
  key_path: /etc/kitploit/key.pem

database:
  type: sqlite
  path: /var/lib/kitploit/data.db

logging:
  level: info
  file: /var/log/kitploit/kitploit.log

# Zeigt die Hilfe an
kitploit-tool --help

# Führt einen Scan durch
kitploit-tool scan --target example.com

# Listet alle verfügbaren Module auf
kitploit-tool modules list

# Zeigt den Status des Servers an
kitploit-tool status

# Startet den Server im Hintergrund
kitploit-tool server start --daemon

# Stoppt den Server
kitploit-tool server stop

  0) owner  files forward proxy shell
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#_vtQ0JCPe7s
  1) ana    files  expires in 6d
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#T-Ty_HhvLfY
  2) ben    files /srv/photos
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#L6La8OzBO74
  3) dev    forward 127.0.0.1:5432 shell
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#8kmI3LYzB7E
```
`owner` ist der eigene Code der Identität und gewährt alles, was der Listener bereitstellt; sende stattdessen einen der anderen. Die Konsole akzeptiert entweder das Label oder die Zahl daneben, also bewirken `rm 2` und `rm ben` dasselbe.

Ein `grant` wird in den Worten geschrieben, die `serve` akzeptiert, und es kann nur einschränken, was der Listener bereits bereitstellt. Das bedeutet, dass ein Link nicht darauf beschränkt ist, Fähigkeiten auszuwählen: Er kann ein Unterverzeichnis des freigegebenen Ordners, eine Teilmenge der Weiterleitungsziele oder einen einzelnen Befehl für `shell` benennen. Lasse `grant` weg und der Link gewährt alles, was der Listener tut. Fordere etwas außerhalb der Reichweite des Listeners an und die Konsole lehnt es mit derselben Meldung ab, die `serve` dir geben würde.

Das Label identifiziert einen Link, nicht seine Bedingungen, sodass zwei Personen Links mit identischen Grants und Ablaufzeiten halten können und du dennoch einen widerrufen kannst, ohne den anderen anzutasten.

Widerruf und Ablauf erreichen bereits geöffnete Sitzungen: Die Verbindung wird geschlossen und dem Inhaber wird der Grund mitgeteilt, statt dass es still wird. Und ein abgelaufener Code wird zurückgezogen statt pausiert – die Erneuerung eines Eintrags erzeugt einen neuen, sodass die bereits gesendete URL tot bleibt.

### Kopplung mit einem 6-stelligen Code

Wenn du keine URL einfügen oder einen QR-Code scannen kannst, etwa am Telefon oder in Rufweite, gibt `bitbang serve` auch einen kurzen **Kopplungscode** aus. Die andere Partei öffnet `bitba.ng/<code>` (oder führt `bitbang connect <code>` aus), ihr Bildschirm zeigt eine zweite 6-stellige Zahl, und sie liest *diese* dir vor. Du tippst sie ein, um zu bestätigen. Ein Man-in-the-Middle kann die beiden Zahlen nicht zur Übereinstimmung bringen, und die Kopplung speichert die Geräteverbindungsdaten für das nächste Mal, z. B. `bitbang connect nas1`. Falls du [Magic Wormhole](https://github.com/magic-wormhole/magic-wormhole) kennst, ist die Form ähnlich – ein gesprochener Code, der zwei Maschinen sicher einander vorstellt.

![Der Server gibt einen 5-minütigen Kopplungscode aus; die andere Partei gibt ihn auf bitba.ng ein, ihr Bildschirm zeigt eine 6-stellige Herausforderung zum Vorlesen, und das Zurücktippen auf dem Server-Rechner bestätigt die Verbindung](https://assets.kitploit.com/production/public/readmes/47068/a5df368669e25ce461cc712a7c83d5dc41459c94a2f8281992ae695f4543223b.webp)

### Eigener TURN-Server

Die meisten Verbindungen laufen direkt Peer-to-Peer. Wenn beide Enden hinter einer NAT sitzen, die kein Hole-Punching zulässt, benötigt der Datenverkehr ein Relay, und standardmäßig ist das unseres. `-ice-servers` weist den Listener stattdessen auf dein eigenes an:```
bitbang serve -ice-servers ~/turn.json
```
Der Listener übergibt die Konfiguration bei der Registrierung an den Signalisierungsserver, und der Server
gibt sie an jeden weiter, der sich verbindet – so verwenden beide Enden dein Relay und unseres ist nie involviert.
Jedes coturn oder ein gehosteter Anbieter wie Cloudflare oder Twilio funktioniert.

Die Datei ist JSON, in einer dieser drei Formen, die dir dein Anbieter übergeben hat:```json
[{"urls": ["turn:turn.example.net:3478"], "username": "user", "credential": "pass"}]
```
I need the actual content of chunk 17 to translate it. Please provide the Markdown text you'd like translated.```json
{"ice_servers": [{"urls": "stun:stun.example.net:3478"}]}
```
- **`-p, --port`** – Port für den Dienst (Standard: `8080`).
- **`-t, --threads`** – Anzahl der Threads (Standard: `4`).
- **`-v, --verbose`** – Ausführliche Ausgabe aktivieren.
- **`-h, --help`** – Hilfe anzeigen.

### Beispiele

```bash
# Starte den Dienst auf Port 9090 mit 8 Threads
./tool -p 9090 -t 8

# Starte mit ausführlicher Ausgabe
./tool -v
```

## Konfiguration

Die Konfiguration erfolgt über eine YAML-Datei. Ein Beispiel:

```yaml
server:
  host: 0.0.0.0
  port: 8080
  threads: 4

logging:
  level: info
  format: json
```

| Option | Typ | Standard | Beschreibung |
|--------|-----|----------|--------------|
| `server.host` | string | `0.0.0.0` | Bind-Adresse |
| `server.port` | int | `8080` | Port |
| `server.threads` | int | `4` | Anzahl der Threads |
| `logging.level` | string | `info` | Log-Level |
| `logging.format` | string | `json` | Log-Format |

## Installation

### Voraussetzungen

- Go 1.21 oder höher
- `git`

### Aus dem Quellcode

```bash
git clone https://github.com/example/tool.git
cd tool
go build -o tool .
```

### Über `go install`

```bash
go install github.com/example/tool@latest
```

## Verwendung

Nach dem Start ist der Dienst unter `http://localhost:8080` erreichbar.

### API-Endpunkte

| Methode | Pfad | Beschreibung |
|---------|------|--------------|
| `GET` | `/health` | Health-Check |
| `GET` | `/api/v1/status` | Status abrufen |
| `POST` | `/api/v1/scan` | Scan starten |

### Beispiel-Request

```bash
curl -X POST http://localhost:8080/api/v1/scan \
  -H "Content-Type: application/json" \
  -d '{"target": "example.com"}'
```

## Fehlerbehebung

### Häufige Probleme

- **Port bereits belegt** – Ändern Sie den Port mit `-p`.
- **Berechtigung verweigert** – Stellen Sie sicher, dass der Benutzer über ausreichende Rechte verfügt.
- **Zeitüberschreitung bei der Verbindung** – Prüfen Sie Firewall-Einstellungen.

## Lizenz

Dieses Projekt steht unter der MIT-Lizenz. Weitere Informationen finden Sie in der Datei [LICENSE](https://github.com/richlegrand/bitbang-cli/blob/HEAD/LICENSE).```json
{"iceServers": [{"urls": ["turn:turn.example.net:3478"], "username": "u", "credential": "p"}]}
```
`urls` akzeptiert einen String oder eine Liste; `username` und `credential` sind für TURN gedacht und können bei einem reinen STUN-Eintrag weggelassen werden. Der Pfad kann absolut, relativ oder mit `~`-Wurzel sein. Eine Datei, die nicht geparst werden kann, stoppt den Listener beim Start, anstatt stillschweigend auf einen Fallback zurückzugreifen.

Wenn eine Sitzung weitergeleitet wird, ohne dass dies angefordert wurde, sagt `bitbang connect` dies ausdrücklich, anstatt dich im Unklaren zu lassen, warum es sich langsam anfühlt. Der Listener protokolliert es in jedem Fall (`via RELAY`), und `-relay` / `-norelay` erzwingen die Frage in die eine oder andere Richtung, wenn du einen Pfad diagnostizierst.

Erwähnenswert: Es geht darum, wer die Bytes transportiert, nicht wer sie lesen kann. Ein Relay sieht nur DTLS-Chiffretext, auch unseren. Betreibe dein eigenes, wenn du mehr TURN benötigst, als wir bereitstellen können (wir begrenzen derzeit die Zeit).

### Verbindung aus einem Browser

Öffne die URL. Je nachdem, was ausgeliefert wird, erhältst du:

- **Shell** -- ein vollwertiges Terminal in der Seite (Farben, Größenänderung, Kopieren/Einfügen).
- **Dateien** -- durchsuchen, Vorschau, Download und Upload.
- **Proxy** -- gib eine LAN-Adresse ein (`nas.local`, `192.168.1.10:8080`, `localhost:3000/admin`) und nutze die App, als wärst du lokal. Logins, Cookies, Uploads und Streaming funktionieren alle.

<!-- TODO: per-feature demos -->
<!-- Remote shell in a browser tab -->
<!-- Streaming Jellyfin through the proxy -->

### Verbindung aus der CLI```
bitbang connect <url>                                   # interactive shell
bitbang connect <url> -- tail -f /var/log/syslog        # one-shot command
bitbang connect <url> -L 15432:db.internal:5432         # local TCP forwarding
bitbang connect <url> -L 14450:nas.local:445 -L 15900:[fd00::20]:5900
bitbang cp <url>:/var/log/app.log ./app.log             # copy files, scp-style
bitbang cp - <url>:/tmp/firmware.bin < firmware.bin     # stdin/stdout work too
```
`-L` leitet **nur TCP** weiter, wie `ssh -L`. `-L` bindet an `127.0.0.1`, sofern du nicht
`-g` übergibst, wodurch der weitergeleitete Port aus deinem lokalen Netzwerk erreichbar wird – und
jeder, der ihn erreicht, bekommt, was auch immer der Tunnel erreicht, ohne dass eine BitBang-
Anmeldedaten davor liegen.

Der Listener benötigt `bitbang serve forward` oder `bitbang serve`. Standardmäßig erreicht ein
`forward`-Link **jeden Host:Port, den der Listener erreichen kann**, nicht nur den, den du im Sinn
hattest. Ein Link, der für eine Datenbank ausgegeben wurde, erreicht also auch den Rest dieses
Netzwerks. Schränke ihn ein, indem du benennst, was er erreichen darf:```
bitbang serve forward db.internal:5432        # this link reaches one service
```
Jede erfolgreiche Verbindung oder Kopplung wird in `~/.bitbang/devices.json` gespeichert, sodass ab dann ein kurzer Name genügt: `bitbang connect nas1`.

## Plattformunterstützung

Eine Binärdatei pro Plattform, keine Laufzeitabhängigkeiten. Alles funktioniert
überall, außer in den beiden unten hervorgehobenen Zeilen.

|                                          | Linux | macOS | Windows |
| ---------------------------------------- | :---: | :---: | :-----: |
| Shell, Dateien, Proxy (`bitbang serve`)   |  ja   |  ja   |   ja    |
| TCP-Weiterleitung (`-L`)                 |  ja   |  ja   |   ja    |
| Zugriffslinks – Gewährung, Ablauf, Widerruf |  ja   |  ja   |   ja    |
| Eigener TURN-Server                      |  ja   |  ja   |   ja    |
| Kopplung mit 6-stelligem Code            |  ja   |  ja   |   ja    |
| Die Listener-Konsole (Enter)             |  ja   |  ja   |   ja    |
| `bitbang connect`, `bitbang cp`          |  ja   |  ja   |   ja    |
| Anzeigen einer geteilten Sitzung         |  ja   |  ja   |   ja    |
| **Hosten einer Freigabe** (`bitbang share`) |  ja   |  ja   |  nein * |
| **Terminalgröße während der Verbindung ändern** |  ja   |  ja   |  nein ** |

\* `bitbang share` veröffentlicht eine tmux-Sitzung, daher benötigt das Hosten tmux –
Linux, macOS oder WSL. Natives Windows kann Freigabe-URLs weiterhin mit
`bitbang connect` öffnen.

\*\* Ein Windows-Connector bemerkt keine Größenänderung seines Terminals, daher
behält die entfernte Shell die Größe, mit der sie gestartet wurde, bis du dich
neu verbindest. Unix erhält dies über `SIGWINCH`, wofür Windows kein Äquivalent hat.

## Sicherheit

- **Selbstzertifizierende Identität.** Beim ersten Start generiert `bitbang` ein RSA-Schlüsselpaar unter `~/.bitbang/<program>/`; die Geräte-UID wird vom öffentlichen Schlüssel abgeleitet, sodass das Vortäuschen eines Geräts bedeutet, ein zweites Urbild seiner UID zu finden.
- **Das Geheimnis berührt den Server nie.** Der Zugriffscode befindet sich im URL-Fragment (`#…`), das Browser nie senden – `bitba.ng` vermittelt die Verbindung, ohne je die Anmeldedaten zu sehen, die sie autorisieren.
- **Ende-zu-Ende-Verschlüsselung.** Der gesamte Datenverkehr läuft über WebRTCs DTLS. Der Signalisierungsserver sieht nur den öffentlichen Schlüssel, die abgeleitete UID und Verbindungsmetadaten – nie deine Daten. Ein TURN-Relay, falls benötigt, sieht nur Chiffretext.
- **Verifizierte Kopplung.** Die beim Code-Pairing vorgelesene Zahl ist eine kurze Authentifizierungszeichenfolge (SAS), die auf beiden Enden unabhängig aus den ausgehandelten DTLS-Fingerprints und zwei festgelegten Nonces berechnet wird – ein Man-in-the-Middle, dessen Fingerprints zwangsläufig abweichen, kann die beiden Zahlen nicht zur Übereinstimmung bringen.
- **Die URL ist eine Inhaber-Anmeldedaten.** Jeder, der sie hat, erhält, was du gewählt hast zu servieren – eine Shell, wenn du `serve shell` ausgeführt hast. Teile sie entsprechend.
- **Optionaler PIN** (`--pin`) für permanente oder headless-Setups und **Einwegmodus** (`-ephemeral`) für eine frische Identität bei jedem Lauf.
- **Was der Server trotzdem sieht.** Nicht nichts. Er vermittelt die Einführung, daher
  beobachtet er die IP-Adressen beider Enden, wann sie sich verbinden und wie viel sie
  austauschen. Ende-zu-Ende-Verschlüsselung hält ihn aus deinen Daten heraus, nicht aus den
  Metadaten darum herum – *minimales Vertrauen* ist eine treffendere Beschreibung als
  *vertrauenslos*.
- **Ein Browser vertraut der geladenen Seite.** Der Browser-Client ist JavaScript,
  das vom Signalisierungsserver ausgeliefert wird. Das Öffnen einer URL bedeutet also, diesem Server
  zu vertrauen, ehrlichen Code auszuliefern. `bitbang connect` hat eine solche Abhängigkeit nicht: Es ist eine
  Binärdatei, die du installiert und mit einer Prüfsumme versehen hast. Wenn dir dieser Unterschied wichtig ist,
  verbinde dich mit der CLI.

Wie sich die beiden Enden gegenseitig authentifizieren, sodass der Signalisierungsserver sich nicht
in die Verbindung einschalten kann, wird hier ausführlich behandelt: [*Trustless Signaling: Authentication Without a Central Authority*](https://github.com/richlegrand/bitbang/blob/main/trustless-signaling.md).

## Warum?

- **Nichts zu öffnen oder zu konfigurieren.** Funktioniert hinter NAT, CGNAT oder einem abgesicherten Netzwerk – keine Router-Änderungen, kein VPN, kein Tunnel-Daemon.
- **Nichts auf der verbindenden Seite zu installieren.** Ein Browser genügt. Eine CLI ist da, wenn du Skripte, Pipes und Dateikopie möchtest.
- **Privat von Natur aus.** Der Datenverkehr ist WebRTC/DTLS, Peer-to-Peer. Der Signalisierungsserver sieht ihn nie; wenn ein direkter Pfad nicht möglich ist, transportiert ein TURN-Relay nur Chiffretext.
- **Kein Konto, keine Telemetrie.**


### Warum nicht einfach SSH? Oder Tailscale?

Kurz gesagt: Für eine Maschine, in die du bereits per SSH einsteigen kannst, oder eine Flotte eigener
Geräte, auf denen du etwas installieren kannst, nutze weiterhin, was du hast. `bitbang` ist für den Fall, dass das
andere Ende eine Person statt eines Geräts ist, oder wenn du an deinem Standort nichts installieren kannst. Beide Fragen werden ausführlich in der
**[FAQ](https://github.com/richlegrand/bitbang-cli/blob/HEAD/FAQ.md)** beantwortet.

## Installation```
curl -sSfL bitba.ng/install | sh
```
Linux und macOS. Erkennt dein Betriebssystem und die Architektur (`amd64`, `arm64` und `armv7` auf Linux), lädt die Binärdatei vom neuesten [GitHub-Release](https://github.com/richlegrand/bitbang-cli/releases) herunter, verifiziert deren SHA-256 gegen die `checksums.txt` des Releases und installiert sie nach `~/.local/bin/bitbang`.

Windows-Builds werden als `bitbang-windows-amd64.exe` und
`bitbang-windows-arm64.exe` veröffentlicht. Lade die passende Binärdatei von den Releases herunter,
benenne sie in `bitbang.exe` um und lege sie in deinen `PATH`.
**Aus dem Quellcode bauen:** siehe [unten](#building-from-source).

**macOS und Gatekeeper.** Der Installations-Einzeiler oben ist davon nicht betroffen: `curl` setzt
das Attribut `com.apple.quarantine` nicht, daher läuft die damit abgerufene Binärdatei
normal. Wenn du stattdessen `bitbang-darwin-arm64` von der Releases-Seite
in einem Browser herunterlädst, stellt macOS sie unter Quarantäne und weigert sich, sie zu öffnen, da die Release-Binärdateien
nicht notarisiert sind. Entferne die Quarantäne mit einem der folgenden Befehle:```
xattr -d com.apple.quarantine ./bitbang-darwin-arm64
```
oder mit Rechtsklick auf die Datei im Finder und Auswahl von „Öffnen“, was eine einmalige
Überschreibung ermöglicht. Alternativ kann man aus dem Quellcode bauen, was niemals unter Quarantäne gestellt wird.

**Windows und SmartScreen.** Dasselbe passiert unter Windows, aus demselben
Grund. Ein Browser-Download fügt das Mark-of-the-Web hinzu, daher zeigt der erste Start
*„Windows hat Ihren PC geschützt“* – wählen Sie **Weitere Informationen** und dann **Trotzdem ausführen**. Die
Release-Binärdateien sind nicht code-signiert, daher ist dies zu erwarten und kein Zeichen dafür,
dass etwas nicht stimmt. Das Abrufen der `.exe` mit `curl` oder PowerShells
`Invoke-WebRequest` fügt es nicht hinzu, ebenso wenig wie das Bauen aus dem Quellcode.

### Installationsoptionen

Eine Version festlegen, den Speicherort ändern oder das Skript vor der Ausführung lesen:```
curl -sSfL bitba.ng/install | sh -s -- --version 0.5.0
curl -sSfL bitba.ng/install | sh -s -- --prefix /usr/local/bin

curl -sSfL bitba.ng/install -o install.sh && less install.sh && sh install.sh
```
Release-Tags haben kein `v`-Präfix (`0.5.0`, nicht `v0.5.0`).

### So funktioniert die Install-URL

`bitba.ng/install` ist eine Weiterleitung, kein gehostetes Skript. Die Kette:

1. `curl` trifft auf `https://bitba.ng/install`, das per 302 auf [`install.sh`](https://github.com/richlegrand/bitbang-cli/blob/HEAD/install.sh) in diesem Repo (auf `main`) weiterleitet.
2. Das Skript läuft in deiner Shell, erkennt OS+Architektur und lädt das Binär-Asset von `https://github.com/richlegrand/bitbang-cli/releases/latest/download/bitbang-linux-<arch>` herunter.
3. Es holt `checksums.txt` aus demselben Release und verifiziert die SHA-256-Prüfsumme der Binärdatei.
4. Installiert nach `~/.local/bin` (überschreibbar).

Das Installationsskript liegt in diesem Repo, direkt neben dem Code, den es installiert – du kannst es also zusammen mit der Binärdatei prüfen, und der kanonische bitba.ng-Host besitzt nur die Kurz-URL. Selbst-Hoster können das `/install` ihres eigenen Hosts auf jedes beliebige Skript zeigen lassen, das sie ausliefern: Die `INSTALL_URL`-Umgebungsvariable des Signalisierungsservers steuert das Weiterleitungsziel (leer → 404).

## Befehlsreferenz

Jeder Unterbefehl und jedes Flag ist in **[CLI.md](https://github.com/richlegrand/bitbang-cli/blob/HEAD/CLI.md)** dokumentiert, und `bitbang <command> --help` gibt dasselbe im Terminal aus.

## Aus dem Quellcode bauen

Erfordert Go 1.25+. Reines Go, statisch gelinkt (`CGO_ENABLED=0`) – triviales Cross-Compiling, keine Laufzeitabhängigkeiten.```
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/
```
From Windows Command Prompt:```bat
go build -o bitbang.exe .\cmd\bitbang
go test .\...
run_tests.cmd unit
```
Shell-Befehle, Dateifreigabe, Proxying und der CLI-Client werden unter
Windows unterstützt. Interaktive Browser- und CLI-Shells verwenden Windows ConPTY, einschließlich
Terminal-Eingabe-Echo, Zeilenbearbeitung, VT-Ausgabe und Größenänderungsereignisse. ConPTY erfordert
Windows 10 Version 1809 oder Windows Server 2019 oder neuer.

## Diagramme

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/d68fcddad62ab84f11a549906a2b5abf2330fb25f39b3c1a1266eac7257a080d.png" alt="bitbang CLI-Shell und Dateifreigabe" width="760">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/55bb6866c22504a6434e3dee8cb998e747cd73cb9d0bfa5e0bc0ede7b90ce262.png" alt="bitbang CLI-Proxy-Betrieb" width="720">  
</p>

## Roadmap

Bereits verfügbar: **Shell, Dateien und Proxy**, erreichbar über den Browser oder die CLI, plus **TCP-Portweiterleitung**, scp-artiges Dateikopieren, **Ad-hoc-Kopplung** mit einer gespeicherten Gerätetabelle, **Terminal-Freigabe** (`bitbang share`) und **Zugriffslinks** (`bitbang link`), die einschränken und ablaufen lassen, was eine URL gewährt. Entworfen und in Arbeit:

- **Serielle Brücke** -- ein entferntes `/dev/ttyUSB0` über einen lokalen virtuellen Port ansteuern (z. B. Arduino IDE über das Internet ausführen). Ein Issue wurde [hier](https://github.com/richlegrand/bitbang-cli/issues/3) eröffnet.
- **Remote-Desktop** -- Bildschirm über einen WebRTC-Videotrack, Tastatur/Maus über den Datenkanal.

## Lizenz

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

## Mitwirken

Issues und PRs sind willkommen.

Rezepte sind anders: Sie leben im [Cookbook](https://github.com/richlegrand/bitbang/blob/main/cookbook.md),
im [bitbang](https://github.com/richlegrand/bitbang)-Repository, weil sie sich über
jedes Projekt erstrecken statt nur über dieses. Ein Rezept hinzuzufügen ist ein PR dort.

Es *gelistet* zu bekommen ist ein zweiter, kleiner PR pro Projekt, dessen README es
anzeigen soll -- die [Rezepte](#recipes)-Liste oben wird hier von Hand gepflegt. Das ist
bewusst so: Jedes Projekt entscheidet, welche Rezepte es seinen eigenen
Lesern präsentieren möchte, statt dass jedes README jedes Rezept enthält.