`serve` imprime um URL. Abra-o em qualquer navegador e você obtém um terminal, um navegador de arquivos e um proxy para a rede dessa máquina — ou alcance a mesma máquina a partir de outro terminal com `bitbang connect <url>`, que adiciona encaminhamento de porta (`-L`) e cópia de arquivos (`bitbang cp`). A conexão é criptografada de ponta a ponta e ponto a ponto; o servidor `bitba.ng` apresenta as duas extremidades e depois se afasta.

`bitbang` é um único binário Go estático. Faz parte do [projeto BitBang](https://github.com/richlegrand/bitbang); este [whitepaper](https://github.com/richlegrand/bitbang/blob/main/whitepaper.md) aborda o design em profundidade.

## Como se compara

|                                | ngrok                  | Tailscale                      | `bitbang`           |
| ------------------------------ | ---------------------- | ------------------------------ | ------------------- |
| Configuração antes do primeiro uso         | Conta + authtoken    | Conta + login em cada dispositivo | **Execute um comando** |
| Para compartilhar algo, você executa    | um servidor web, além do ngrok | o cliente deles em ambas as máquinas | **`bitbang serve`** |
| O que um navegador na extremidade oposta obtém | o servidor web que você já estava executando | nada — ele precisa do cliente deles | **um terminal, um navegador de arquivos e aplicativos web na rede remota** |
| Caminho de dados                      | servidores deles          | P2P (fallback de relay)           | **P2P (fallback de relay)** |
| Criptografado de ponta a ponta           | Não por padrão         | Sim                            | **Sim**             |

## Receitas rápidas

**Acesse um serviço em casa**

- [Monte seu NAS doméstico de qualquer lugar (SMB)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#mount-your-home-nas-from-anywhere-smb)
- [Assista à sua biblioteca de mídia de qualquer lugar (Jellyfin)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-your-media-library-from-anywhere-jellyfin)
- [Use seu próprio LLM de qualquer lugar (Ollama, Open WebUI)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#use-your-own-llm-from-anywhere-ollama-open-webui)
- [Verifique suas câmeras de segurança (Frigate)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-security-cameras-frigate)
- [Acesse sua automação residencial sem expô-la (Home Assistant)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-your-home-automation-without-exposing-it-home-assistant)
- [Imprima na sua impressora doméstica (IPP, CUPS)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#print-to-your-home-printer-ipp-cups)

**Acesse uma máquina**

- [Obtenha um shell em uma máquina atrás de NAT](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-on-a-machine-behind-nat)
- [Obtenha um shell do seu celular](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-from-your-phone)
- [Área de trabalho remota em uma máquina Windows (RDP)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#remote-desktop-into-a-windows-machine-rdp)
- [Acesse uma área de trabalho Linux ou Mac (VNC)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-linux-or-mac-desktop-vnc)
- [SSH para uma máquina sem porta aberta (OpenSSH)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#ssh-to-a-machine-with-no-open-port-openssh)
- [Configure um Raspberry Pi headless](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#set-up-a-headless-raspberry-pi)

**Compartilhe com outra pessoa**

Compartilhar envolve simplesmente dar a alguém um URL único ou código QR que concede acesso. As permissões podem ser personalizadas e definidas para expirar em minutos, horas, etc.

- [Compartilhe arquivos sem enviá-los para lugar nenhum](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#share-files-without-uploading-them-anywhere)
- [Mostre seu projeto a alguém](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#show-someone-your-project)
- [Dê a alguém um acesso que expira](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#give-someone-access-that-expires)
- [Verifique sua sessão de agente pelo celular (Claude Code, tmux)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-agent-session-from-your-phone-claude-code-tmux)
- [Conserte o roteador de outra pessoa](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#fix-someone-elses-router)

**Desenvolvimento e dispositivos**

- [Acesse um banco de dados a partir da sua máquina de desenvolvimento (Postgres, MySQL)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-database-from-your-dev-machine-postgres-mysql)
- [Sincronize dispositivos que não conseguem se encontrar (Syncthing)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#sync-devices-that-cannot-find-each-other-syncthing)
- [Assista a um robô a partir de um navegador (ROS, Foxglove)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-a-robot-from-a-browser-ros-foxglove)

**Técnicas**

- [O que um listener de encaminhamento expõe](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#what-a-forwarding-listener-exposes)
- [Permita que outras máquinas na sua LAN usem um encaminhamento](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#let-other-machines-on-your-lan-use-a-forward)
- [Conhecido por não funcionar](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#known-not-to-work)

## Usando `bitbang`

Toda conexão tem duas extremidades: um **listener** (`bitbang serve`, executado na máquina que está sendo acessada) e um **connector** (um navegador, ou a CLI `bitbang`, na máquina que está acessando). Um único URL de listener atende aos dois tipos de connector.

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

O comando retorna após publicar, então `Ctrl-Z`, `bitbang share`, `fg`
funciona para uma tarefa já em andamento. Hospedar exige tmux 3.2+ no Unix ou
WSL. Clientes Windows nativos podem abrir as URLs, mas não podem hospedar um share.

Por padrão, o comando imprime duas URLs de bearer:

- A **URL de Controle** pode digitar com a mesma autoridade do teclado local.
  Apenas um controlador pode se conectar por vez.
- A **URL de Visualização** é somente leitura. A entrada é descartada antes de chegar ao tmux, e
  até `--max-viewers` espectadores podem se conectar ao mesmo tempo (padrão 16).

`--read-only` omite a credencial de controle por completo. Os limites de espectadores e controladores
são mantidos durante toda a vida de cada conexão, mesmo antes de abrir um shell.

Os shares rodam até serem interrompidos por padrão; `--ttl` define uma duração (ex.: `--ttl 1h`).
As URLs de share são efêmeras e nunca são salvas em `devices.json`. `share stop`,
expiração do TTL ou remoção da sessão de origem desconecta os pares remotos sem
interromper a sessão de origem.

Executar `bitbang share` novamente reimprime as URLs do share em execução. Se você
passar uma flag que conflita com o que está em execução (digamos `--read-only`
contra um share que tem uma URL de controle), ele informa isso em vez de
devolver as URLs antigas; `bitbang share rotate` substitui o share
por um que usa as novas flags.

Um worker em segundo plano roda em uma sessão de gerenciamento tmux destacada `_bbshare_*`,
então não há daemon ou arquivo PID para gerenciar.

Compartilhar não altera nenhuma opção do tmux. Com o padrão `window-size latest` do tmux, a
janela segue o cliente leitura-escrita ativo; um espectador solitário ainda fornece o
único tamanho disponível. Se `window-size` foi sobrescrito, `share` informa isso,
mas não altera a configuração do usuário.

### Concedendo acesso limitado: `bitbang link`

Um listener, uma URL e quantos **links de acesso** você precisar. Cada um é um
código separado nessa mesma URL, concedendo um subconjunto do que o listener oferece
e, opcionalmente, expirando em um horário fixo:```
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

Aqui está a tradução do conteúdo:

```markdown
## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)
- Acesso à internet para baixar dependências

### Passos de Instalação

1. Clone o repositório:
   ```bash
   git clone https://github.com/example/tool.git
   cd tool

python tool.py scan --target example.com

python tool.py scan --target https://example.com

python tool.py scan --target https://example.com --verbose

python tool.py scan --target https://example.com --output results.txt

# Configuração da ferramenta
tool:
  timeout: 30
  retries: 3
  user_agent: "Mozilla/5.0 (compatible; Tool/1.0)"

logging:
  level: "INFO"
  file: "tool.log"

pip install -r requirements.txt --upgrade

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

  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` é o código da própria identidade e concede tudo o que o listener serve; envie
um dos outros. O console aceita tanto o rótulo quanto o número ao lado
dele, então `rm 2` e `rm ben` fazem a mesma coisa.

Um `grant` é escrito nas palavras que `serve` aceita, e só pode restringir o que o
listener já serve. Isso significa que um link não se limita a escolher capacidades:
ele pode nomear um subdiretório da pasta compartilhada, um subconjunto dos alvos de encaminhamento, ou
um único comando para `shell`. Omita `grant` e o link concede tudo o que o listener
faz. Peça algo fora do alcance do listener e o console recusa com a
mesma mensagem que `serve` lhe daria.

O rótulo é o que identifica um link, não os seus termos, então duas pessoas podem ter links
com grants e expirações idênticos e você ainda pode revogar um sem tocar no
outro.

A revogação e a expiração alcançam sessões já abertas: a conexão fecha
e o titular é informado do motivo, em vez de ficar em silêncio. E um código expirado é
aposentado, não pausado — renovar uma entrada gera um novo, então o URL que você
já enviou permanece morto.

### Emparelhamento com um código de 6 dígitos

Quando você não consegue colar um URL ou escanear um código QR, como quando está ao telefone, ou a uma distância de gritos, `bitbang serve` também imprime um curto **código de emparelhamento**. A outra parte abre `bitba.ng/<code>` (ou executa `bitbang connect <code>`), a tela dela mostra um segundo número de 6 dígitos, e ela lê *esse* número de volta para você. Você o digita para aprovar. Um intermediário (man-in-the-middle) não consegue fazer os dois números coincidirem, e o emparelhamento salva as credenciais de conexão do dispositivo para a próxima vez, ex. `bitbang connect nas1`. Se você conhece o [Magic Wormhole](https://github.com/magic-wormhole/magic-wormhole), o formato é semelhante — um código falado que apresenta duas máquinas com segurança.
	
![O servidor imprime um código de emparelhamento de 5 minutos; a outra parte o insere em bitba.ng, a tela dela mostra um desafio de 6 dígitos para ler em voz alta, e digitá-lo de volta na máquina servidora aprova a conexão](https://assets.kitploit.com/production/public/readmes/47068/a5df368669e25ce461cc712a7c83d5dc41459c94a2f8281992ae695f4543223b.webp)

### Traga seu próprio TURN

A maioria das conexões vai direto ponto a ponto. Quando ambas as extremidades estão atrás de um NAT que
não faz hole-punching, o tráfego precisa de um relay, e por padrão é o nosso. `-ice-servers`
aponta o listener para o seu próprio:```
bitbang serve -ice-servers ~/turn.json
```
O listener entrega a configuração ao servidor de sinalização no registro, e o servidor
a fornece a quem se conectar — então ambas as extremidades usam o seu relay e o nosso nunca é envolvido.
Qualquer coturn, ou um provedor hospedado como Cloudflare ou Twilio, funciona.

O arquivo é JSON, em qualquer uma destas três formas que o seu provedor forneceu:```json
[{"urls": ["turn:turn.example.net:3478"], "username": "user", "credential": "pass"}]
```
Aqui está a tradução do conteúdo do chunk 17:

```markdown
## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)
- Acesso à internet para baixar dependências

### Passos de Instalação

1. Clone o repositório:

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

2. Instale as dependências:

```bash
pip install -r requirements.txt
```

3. Execute a ferramenta:

```bash
python main.py --help
```

## Uso

### Exemplos Básicos

Para executar uma varredura básica:

```bash
python main.py scan --target example.com
```

Para usar o modo verboso:

```bash
python main.py scan --target example.com --verbose
```

### Opções de Linha de Comando

| Opção | Descrição |
|-------|-----------|
| `--target` | Especifica o alvo da varredura |
| `--verbose` | Ativa a saída detalhada |
| `--output` | Define o arquivo de saída |
| `--threads` | Número de threads a serem usadas |

### Configuração

O arquivo de configuração `config.yaml` permite personalizar o comportamento da ferramenta:

```yaml
scan:
  threads: 10
  timeout: 30
  retries: 3
output:
  format: json
  directory: ./results
```

## Solução de Problemas

### Erros Comuns

**Erro: `ModuleNotFoundError`**

Certifique-se de que todas as dependências foram instaladas corretamente:

```bash
pip install -r requirements.txt
```

**Erro: `PermissionError`**

Execute a ferramenta com as permissões adequadas:

```bash
sudo python main.py
```

### Perguntas Frequentes

**P: A ferramenta é compatível com Windows?**

R: Sim, a ferramenta é multiplataforma e funciona em Windows, Linux e macOS.

**P: Posso usar a ferramenta para fins comerciais?**

R: Sim, a ferramenta é licenciada sob a licença MIT e pode ser usada comercialmente.
``````json
{"ice_servers": [{"urls": "stun:stun.example.net:3478"}]}
```
Aqui está a tradução do conteúdo:

```
## 📦 Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)

### Instalação via pip

Para instalar a ferramenta, execute o seguinte comando:

```bash
pip install kitploit-tool
```

### Instalação a partir do código-fonte

Se preferir instalar a partir do código-fonte, clone o repositório e instale as dependências:

```bash
git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt
```

### Verificação da instalação

Para verificar se a instalação foi concluída com sucesso, execute:

```bash
kitploit-tool --version
```

Você deve ver a versão da ferramenta exibida no terminal.

---

## 🚀 Uso

### Comandos básicos

A ferramenta oferece vários comandos para diferentes funcionalidades. Aqui estão alguns exemplos:

```bash
kitploit-tool scan --target example.com
kitploit-tool report --format html
kitploit-tool update
```

### Opções disponíveis

| Opção | Descrição |
|-------|-----------|
| `--target` | Especifica o alvo da varredura |
| `--format` | Define o formato do relatório (html, pdf, txt) |
| `--verbose` | Exibe informações detalhadas durante a execução |
| `--quiet` | Suprime a saída não essencial |
| `--help` | Mostra a ajuda do comando |

### Exemplos de uso

**Varredura básica:**

```bash
kitploit-tool scan --target https://example.com
```

**Varredura com saída detalhada:**

```bash
kitploit-tool scan --target https://example.com --verbose
```

**Geração de relatório em PDF:**

```bash
kitploit-tool report --format pdf
```

---

## ⚙️ Configuração

### Arquivo de configuração

A ferramenta usa um arquivo de configuração localizado em `~/.kitploit/config.yaml`. Você pode criar este arquivo manualmente ou usar o comando de inicialização:

```bash
kitploit-tool init
```

### Variáveis de ambiente

As seguintes variáveis de ambiente são suportadas:

| Variável | Descrição |
|----------|-----------|
| `KITPLOIT_API_KEY` | Chave de API para serviços externos |
| `KITPLOIT_PROXY` | URL do proxy para conexões de rede |
| `KITPLOIT_TIMEOUT` | Tempo limite padrão para solicitações (em segundos) |

---

## 🛠️ Desenvolvimento

### Estrutura do projeto

```
kitploit-tool/
├── kitploit/
│   ├── __init__.py
│   ├── cli.py
│   ├── scanner.py
│   ├── report.py
│   └── utils.py
├── tests/
│   ├── test_scanner.py
│   └── test_report.py
├── requirements.txt
├── setup.py
└── README.md
```

### Executando testes

Para executar a suíte de testes, use:

```bash
pytest tests/
```

### Contribuindo

1. Faça um fork do repositório
2. Crie uma branch para sua feature (`git checkout -b feature/nova-funcionalidade`)
3. Faça commit das suas alterações (`git commit -am 'Adiciona nova funcionalidade'`)
4. Envie para a branch (`git push origin feature/nova-funcionalidade`)
5. Abra um Pull Request

---

## 📄 Licença

Este projeto está licenciado sob a [MIT License](https://opensource.org/licenses/MIT).

---

## 📞 Suporte

Para dúvidas ou problemas, abra uma issue no [repositório oficial](https://github.com/example/kitploit-tool/issues).

---

## 🙏 Agradecimentos

- A todos os contribuidores do projeto
- À comunidade de segurança cibernética
- Aos mantenedores do Kitploit
``````json
{"iceServers": [{"urls": ["turn:turn.example.net:3478"], "username": "u", "credential": "p"}]}
```
`urls` aceita uma string ou uma lista; `username` e `credential` são para TURN e podem ser
omitidos em uma entrada somente STUN. O caminho pode ser absoluto, relativo ou com raiz em `~`. Um arquivo
que não seja analisado interrompe o listener na inicialização, em vez de falhar silenciosamente.

Se uma sessão acabar retransmitida sem que você tenha solicitado, `bitbang connect` informa isso
em vez de deixar você se perguntando por que parece lenta. O listener registra isso
de qualquer forma (`via RELAY`), e `-relay` / `-norelay` forçam a questão de um jeito
ou de outro quando você está diagnosticando um caminho.

Vale dizer: isso é sobre quem carrega os bytes, não quem pode lê-los. Um relay só
vê texto cifrado DTLS, incluindo o nosso. Execute o seu próprio quando precisar de mais TURN do que podemos fornecer (atualmente limitamos o tempo).

### Conectando a partir de um navegador

Abra a URL. Dependendo do que for servido, você obtém:

- **Shell** -- um terminal completo na página (cores, redimensionar, copiar/colar).
- **Arquivos** -- navegar, visualizar, baixar e enviar.
- **Proxy** -- digite um endereço LAN (`nas.local`, `192.168.1.10:8080`, `localhost:3000/admin`) e use o aplicativo como se estivesse local. Logins, cookies, uploads e streaming funcionam todos.

<!-- TODO: demos por recurso -->
<!-- Shell remoto em uma aba do navegador -->
<!-- Transmitindo Jellyfin pelo proxy -->

### Conectando a partir da 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` encaminha **apenas TCP**, como `ssh -L`. `-L` vincula a `127.0.0.1`, a menos que você passe
`-g`, o que torna a porta encaminhada acessível a partir da sua rede local — e
qualquer pessoa que a alcançar obtém o que o túnel alcança, sem nenhuma
credencial BitBang na frente dela.

O ouvinte precisa de `bitbang serve forward` ou `bitbang serve`. Por padrão, um
link `forward` alcança **qualquer host:porta que o ouvinte possa alcançar**, não apenas
aquele que você tinha em mente, então um link entregue para um banco de dados também alcança o restante
dessa rede. Restrinja-o nomeando o que ele pode alcançar:```
bitbang serve forward db.internal:5432        # this link reaches one service
```
Cada conexão ou pareamento bem-sucedido é salvo em `~/.bitbang/devices.json`, então, a partir daí, um nome curto é suficiente: `bitbang connect nas1`.

## Suporte de plataforma

Um binário por plataforma, sem dependências de runtime. Tudo funciona
em todos os lugares, exceto nas duas linhas destacadas abaixo.

|                                          | Linux | macOS | Windows |
| ---------------------------------------- | :---: | :---: | :-----: |
| Shell, arquivos, proxy (`bitbang serve`)     |  sim  |  sim  |   sim   |
| Encaminhamento TCP (`-L`)                     |  sim  |  sim  |   sim   |
| Links de acesso -- concessão, expiração, revogação |  sim  |  sim  |   sim   |
| Traga seu próprio TURN                       |  sim  |  sim  |   sim   |
| Pareamento com código de 6 dígitos               |  sim  |  sim  |   sim   |
| O console do ouvinte (Enter)              |  sim  |  sim  |   sim   |
| `bitbang connect`, `bitbang cp`           |  sim  |  sim  |   sim   |
| Visualizar uma sessão compartilhada                  |  sim  |  sim  |   sim   |
| **Hospedar um compartilhamento** (`bitbang share`)     |  sim  |  sim  |  não *   |
| **Redimensionar terminal enquanto conectado**       |  sim  |  sim  |  não **  |

\* `bitbang share` publica uma sessão tmux, então hospedar uma requer tmux --
Linux, macOS ou WSL. Windows nativo ainda pode abrir URLs de compartilhamento com
`bitbang connect`.

\*\* Um conector Windows não percebe seu terminal sendo redimensionado, então o
shell remoto mantém o tamanho com que começou até você reconectar. Unix
obtém isso de `SIGWINCH`, para o qual o Windows não tem equivalente.

## Segurança

- **Identidade autocertificada.** Na primeira execução, o `bitbang` gera um par de chaves RSA em `~/.bitbang/<programa>/`; o UID do dispositivo é derivado da chave pública, então se passar por um dispositivo significa encontrar uma segunda pré-imagem do seu UID.
- **O segredo nunca toca o servidor.** O código de acesso vive no fragmento da URL (`#…`), que os navegadores nunca enviam -- `bitba.ng` intermedia a conexão sem nunca ver a credencial que a autoriza.
- **Criptografia de ponta a ponta.** Todo o tráfego usa o DTLS do WebRTC. O servidor de sinalização vê apenas a chave pública, o UID derivado e metadados de conexão -- nunca seus dados. Um relay TURN, se necessário, vê apenas texto cifrado.
- **Pareamento verificado.** O número lido em voz alta no pareamento por código é uma string de autenticação curta (SAS), calculada independentemente em ambas as extremidades a partir das impressões digitais DTLS negociadas e dois nonces comprometidos -- um intermediário, cujas impressões digitais necessariamente diferem, não pode fazer os dois números coincidirem.
- **A URL é uma credencial de portador.** Quem a tiver obtém o que você escolheu servir -- um shell, se você executou `serve shell`. Compartilhe-a de acordo.
- **PIN opcional** (`--pin`) para configurações permanentes ou headless, e **modo descartável** (`-ephemeral`) para uma identidade nova a cada execução.
- **O que o servidor ainda vê.** Não é nada. Ele intermedia a introdução, então
  observa os endereços IP de ambas as extremidades, quando elas se conectam e quanto
  trocam. A criptografia de ponta a ponta o mantém fora dos seus dados, não fora dos
  metadados ao redor deles -- *confiança mínima* é uma descrição mais justa do que
  *sem confiança*.
- **Um navegador confia na página que carregou.** O cliente de navegador é JavaScript
  servido pelo servidor de sinalização, então abrir uma URL significa confiar nesse servidor
  para servir código honesto. `bitbang connect` não tem essa dependência: é um
  binário que você instalou e verificou com checksum. Se essa distinção importa para você,
  conecte-se com a CLI.

Como as duas extremidades se autenticam mutuamente, para que o servidor de sinalização não possa
se inserir na conexão, é detalhado aqui: [*Sinalização Sem Confiança: Autenticação Sem Autoridade Central*](https://github.com/richlegrand/bitbang/blob/main/trustless-signaling.md).

## Por quê?

- **Nada para abrir ou configurar.** Funciona atrás de NAT, CGNAT ou uma rede bloqueada -- sem mudanças no roteador, sem VPN, sem daemon de túnel.
- **Nada para instalar no lado que conecta.** Um navegador é suficiente. Uma CLI está disponível quando você quer scripts, pipes e cópia de arquivos.
- **Privado por design.** O tráfego é WebRTC/DTLS, ponto a ponto. O servidor de sinalização nunca o vê; se um caminho direto não for possível, um relay TURN carrega apenas texto cifrado.
- **Sem conta, sem telemetria.**


### Por que não usar apenas SSH? Ou Tailscale?

Resposta curta: para uma máquina na qual você já pode fazer SSH, ou uma frota de seus próprios
dispositivos nos quais você pode instalar, continue usando o que você tem. `bitbang` é para quando a
outra extremidade é uma pessoa em vez de um dispositivo, ou quando você não pode instalar nada
onde está sentado. Ambas as perguntas são respondidas em detalhes no
**[FAQ](https://github.com/richlegrand/bitbang-cli/blob/HEAD/FAQ.md)**.

## Instalação```
curl -sSfL bitba.ng/install | sh
```
Linux e macOS. Detecta o seu SO e arquitetura (`amd64`, `arm64` e `armv7` no Linux), baixa o binário do [último release do GitHub](https://github.com/richlegrand/bitbang-cli/releases), verifica o SHA-256 em relação ao `checksums.txt` do release e instala em `~/.local/bin/bitbang`.

Os builds para Windows são publicados como `bitbang-windows-amd64.exe` e
`bitbang-windows-arm64.exe`. Baixe o binário apropriado em Releases,
renomeie-o para `bitbang.exe` e coloque-o no seu `PATH`.
**Compilar a partir do código-fonte:** veja [abaixo](#building-from-source).

**macOS e Gatekeeper.** O one-liner de instalação acima não é afetado: o `curl` não
define o atributo `com.apple.quarantine`, então o binário que ele busca é executado
normalmente. Se, em vez disso, você baixar `bitbang-darwin-arm64` da página de Releases
num navegador, o macOS o coloca em quarentena e se recusa a abri-lo, porque os binários
dos releases não são notarizados. Limpe-o com qualquer um dos seguintes:```
xattr -d com.apple.quarantine ./bitbang-darwin-arm64
```
ou clique com o botão direito no arquivo no Finder e escolha Abrir, que oferece uma substituição única.
Como alternativa, compile a partir do código-fonte, que nunca entra em quarentena.

**Windows e SmartScreen.** O mesmo acontece no Windows, pelo mesmo
motivo. Um download pelo navegador anexa a Marca da Web, então a primeira execução mostra
*"O Windows protegeu seu PC"* — escolha **Mais informações** e depois **Executar mesmo assim**. Os
binários de lançamento não são assinados com código, então isso é esperado, e não um sinal
de que algo está errado. Baixar o `.exe` com `curl` ou o
`Invoke-WebRequest` do PowerShell não anexa essa marca, e compilar a partir do código-fonte também não.

### Opções de instalação

Fixar uma versão, alterar o local ou ler o script antes de executá-lo:```
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 não têm prefixo `v` (`0.5.0`, não `v0.5.0`).

### Como funciona o URL de instalação

`bitba.ng/install` é um redirecionamento, não um script hospedado. A cadeia:

1. `curl` acessa `https://bitba.ng/install`, que faz 302 para [`install.sh`](https://github.com/richlegrand/bitbang-cli/blob/HEAD/install.sh) neste repositório (no branch `main`).
2. O script é executado no seu shell, detecta SO+arquitetura e baixa o binário de `https://github.com/richlegrand/bitbang-cli/releases/latest/download/bitbang-linux-<arch>`.
3. Ele busca `checksums.txt` da mesma release e verifica o SHA-256 do binário.
4. Instala em `~/.local/bin` (substituível).

O script de instalação fica neste repositório, ao lado do código que ele instala — para que você possa revisá-lo junto com o binário, e o host canônico bitba.ng é dono apenas do URL curto. Quem faz self-host pode apontar o `/install` do próprio host para qualquer script que distribuir: a variável de ambiente `INSTALL_URL` do servidor de sinalização controla o destino do redirecionamento (vazio → 404).

## Referência de comandos

Todos os subcomandos e flags estão em **[CLI.md](https://github.com/richlegrand/bitbang-cli/blob/HEAD/CLI.md)**, e `bitbang <comando>
--help` imprime o mesmo conteúdo no terminal.

## Compilando a partir do código-fonte

Requer Go 1.25+. Go puro, linkagem estática (`CGO_ENABLED=0`) — compilação cruzada trivial, sem dependências em tempo de execução.```
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
```
Comandos de shell, compartilhamento de arquivos, proxy e o cliente CLI são suportados no
Windows. Shells interativos de navegador e CLI usam o ConPTY do Windows, incluindo
eco de entrada do terminal, edição de linha, saída VT e eventos de redimensionamento. O ConPTY requer
Windows 10 versão 1809 ou Windows Server 2019 ou posterior.

## Diagramas

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/d68fcddad62ab84f11a549906a2b5abf2330fb25f39b3c1a1266eac7257a080d.png" alt="Shell CLI do bitbang e compartilhamento de arquivos" width="760">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/55bb6866c22504a6434e3dee8cb998e747cd73cb9d0bfa5e0bc0ede7b90ce262.png" alt="Operação de proxy do CLI do bitbang" width="720">  
</p>

## Roteiro

Disponível hoje: **shell, arquivos e proxy**, acessíveis pelo navegador ou pela CLI, além de **encaminhamento de porta TCP**, cópia de arquivos no estilo scp, **pareamento ad-hoc** com uma tabela de dispositivos salva, **compartilhamento de terminal** (`bitbang share`) e **links de acesso** (`bitbang link`) que restringem e expiram o que uma URL concede. Projetado e a caminho:

- **Ponte serial** -- acionar um `/dev/ttyUSB0` remoto a partir de uma porta virtual local (por exemplo, executar o Arduino IDE pela internet). Uma issue foi aberta [aqui](https://github.com/richlegrand/bitbang-cli/issues/3).
- **Área de trabalho remota** -- tela por uma trilha de vídeo WebRTC, teclado/mouse pelo canal de dados.

## Licença

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

## Contribuindo

Issues e PRs são bem-vindos.

As receitas são diferentes: elas vivem no [cookbook](https://github.com/richlegrand/bitbang/blob/main/cookbook.md),
no repositório [bitbang](https://github.com/richlegrand/bitbang), porque abrangem
todos os projetos, não apenas este. Adicionar uma receita é um PR lá.

Fazer com que ela seja *listada* é um segundo PR pequeno por projeto cujo README deve exibi-la
-- a lista [Receitas](#recipes) acima é mantida aqui manualmente. Isso é
intencional: cada projeto decide quais receitas valem a pena colocar diante de seus
próprios leitores, em vez de cada README crescer com todas as receitas.