Security & Privacy
Your code never leaves your machine. That's not a policy — it's the architecture.
The Short Version
- ✓No cloud servers. Broski connects your phone directly to your own computer. We don't operate servers that touch your code.
- ✓No telemetry. Zero analytics libraries. No Firebase, no Mixpanel, no Sentry, no Amplitude. We literally cannot see what you do.
- ✓No data collection. Your conversations, code, files, and terminal output stay between your phone and your system. Period.
- ✓Encrypted everything. TLS with certificate pinning on local connections. WireGuard encryption on Tailscale. HTTPS on Funnel.
- ✓You run the server. The bridge runs on your machine, in your terminal. You can inspect every line of traffic.
Zero-Cloud Architecture
Unlike cloud-based coding tools that route your code through remote servers, Broski is peer-to-peer. Your phone talks directly to your computer — nothing in between.
The bridge server runs in your terminal on your own machine. It translates between your phone and the AI agent (Claude Code, OpenCode, or Codex) running locally. At no point does any of this traffic pass through a Broski-operated server.
Where Your Data Lives
Here's exactly what goes where. No vague language, no footnotes.
Stays on Your Computer (never leaves)
- •Your source code and project files
- •Session history and AI conversation logs
- •Terminal output and command history
- •Your API keys and credentials (in the OS keychain (macOS Keychain, Windows Credential Manager, or Linux keyring) or local config files)
- •Bridge authentication tokens
- •TLS certificates (self-signed, generated locally)
Stays on Your Phone (encrypted on-device)
- •Connection credentials (in iOS Keychain / Android EncryptedSharedPreferences)
- •Cached sessions and messages (for offline viewing)
- •UI preferences (themes, settings)
- •Voice API keys if you configure voice input (stored encrypted, sent only to provider you chose)
Sent to AI Providers (same as terminal usage)
- •Your prompts and questions to the AI
- •Code snippets the AI reads (only what the agent requests)
- •File contents needed for context
This is handled by the AI agent (Claude Code, OpenCode, Codex) on your system — exactly the same data that would be sent if you used the agent directly in your terminal. Broski doesn't add anything extra.
What Broski Never Sees
- •Your source code or project files
- •Your conversations with AI
- •Your API keys or credentials
- •Your file system or network traffic
- •Any usage data, analytics, or behavioral metrics
Encryption
Every connection between your phone and your computer is encrypted. The method depends on how you connect:
| Connection | Encryption | How It Works |
|---|---|---|
| Local WiFi | TLS + Certificate Pinning | Self-signed cert generated on your system. Your phone pins the certificate hash from the QR code, preventing man-in-the-middle attacks even on untrusted WiFi. |
| Tailscale VPN | WireGuard (end-to-end) | Modern cryptographic protocol. Traffic is encrypted between your devices with no intermediary able to decrypt it. |
| Tailscale Funnel | HTTPS/TLS | Public endpoint with TLS termination at Tailscale's edge. Connection requires Tailscale authentication. |
Certificate Pinning
When you scan the QR code, your phone receives the SHA-256 fingerprint of the bridge's TLS certificate. On every subsequent connection, the app verifies the certificate matches that fingerprint. If someone tries to intercept the connection with a different certificate, the app refuses to connect.
This means even on a compromised WiFi network (coffee shop, hotel, airport), your connection is secure. The bridge generates a fresh self-signed certificate on first run, and auto-renews it before expiry.
Authentication
The bridge uses a cryptographically secure token to authenticate connections. Here's how it works:
Token Security
- • Generated with cryptographic randomness (192 bits of entropy)
- • Validated using constant-time comparison (prevents timing attacks)
- • Stored with restricted file permissions (owner-only read/write)
- • Never transmitted in plaintext (TLS-wrapped)
- • Revokable anytime with
broski --new-token
Connection Handshake
When your phone connects, it presents the auth token before any data is exchanged. The bridge validates the token at the HTTP level — if it doesn't match, the connection is rejected before a WebSocket is even established. No messages, no data, no access.
broski --new-token to generate a new one and rescan on your phone.Filesystem Protection
The bridge restricts which files and directories can be accessed through the mobile app:
- •Allowlist-based access — Only your home directory and common project paths are accessible. Paths outside the allowlist are blocked.
- •Symlink protection — Symbolic links are resolved and re-checked against the allowlist, preventing directory traversal attacks.
- •Path validation — Null bytes, control characters, and excessively long paths are rejected before any file operation.
- •Text-only reads — The file browser only serves text content. Binary files are blocked.
- •Size limits — Large files are truncated to prevent memory exhaustion.
Zero Telemetry
We don't mean “minimal telemetry” or “anonymous analytics.” We mean zero. None. The app and bridge contain:
If the app crashes, we don't know about it unless you email us. If you use a feature 1000 times a day, we have no idea. This is by design — we built a developer tool, not a data product.
Third-Party Services
Broski uses exactly two external services. Here's what they do and what they can see:
Authentication (Google / Apple Sign-In)
Standard OAuth 2.0 identity verification. We use this to know who you are for subscription management.
| Receives | Does NOT Receive |
|---|---|
| Your name and email | Your code or projects |
| OAuth identity token | Your conversations |
| Your API keys | |
| Any app usage data |
Subscription Management (RevenueCat)
Handles App Store / Play Store purchase verification. This is standard infrastructure for subscription apps.
| Receives | Does NOT Receive |
|---|---|
| Purchase transaction data (via Apple/Google) | Your code or projects |
| Subscription status (active/expired) | Your conversations |
| Anonymous app user ID | Your file system |
| Any behavioral data |
On-Device Storage Security
Sensitive data on your phone is stored using platform-native encrypted storage:
| Platform | Storage Method | Encryption |
|---|---|---|
| iOS | Keychain Services | Hardware-backed (Secure Enclave on supported devices) |
| Android | EncryptedSharedPreferences | AES-256 (Android Keystore system) |
Your connection tokens, cached credentials, and voice API keys are stored in this encrypted storage. UI preferences and cached session data also use this encrypted layer.
On your system, the bridge stores its auth token and TLS certificate in ~/.broski/ with restricted file permissions (owner read/write only). Your AI agent's credentials stay in their own secure storage (the OS keychain (macOS Keychain, Windows Credential Manager, or Linux keyring) for Claude Code, config files for OpenCode).
Network Security
Local WiFi
When on the same network, the bridge generates a self-signed TLS certificate. Your phone pins the certificate fingerprint from the QR code and verifies it on every connection. Even if someone is sniffing WiFi traffic, they see encrypted gibberish.
Tailscale VPN
Tailscale uses the WireGuard protocol — a modern, audited cryptographic VPN. Your phone and Mac establish a direct encrypted tunnel. Traffic never passes through Tailscale's servers in plaintext; they only coordinate the connection setup (key exchange).
Tailscale Funnel
Funnel provides a public HTTPS endpoint managed by Tailscale. TLS is terminated at Tailscale's edge with certificates they manage. The bridge runs an additional loopback-only plaintext server that only Tailscale can reach. No dashboard or debug endpoints are exposed on the Funnel path.
No Plaintext Over the Network
If TLS is disabled (for local development only), the bridge automatically binds to 127.0.0.1 (loopback only) — meaning it's only accessible from your own machine, not the network. There's no configuration that exposes unencrypted traffic to your LAN.
Input Validation & Hardening
The bridge validates every message from the mobile app before processing:
- •Prototype pollution protection — All incoming payloads are checked for prototype poisoning keys and rejected if found.
- •Type enforcement — String values are validated to be actual strings before use.
- •Message size limits — Large payloads are rejected to prevent resource exhaustion.
- •Log redaction — Tokens, passwords, API keys, and secrets are automatically redacted from bridge logs.
Permission System
When the AI wants to perform a potentially dangerous action (running a shell command, editing a file, deleting something), you see the request on your phone and explicitly approve or deny it. Nothing happens without your consent.
You can configure permission levels in Settings:
| Preset | Behavior |
|---|---|
| Ask Everything | Approve every tool call individually (safest) |
| Ask Code Changes | Auto-approve reads, ask for writes and commands |
| Trust Me | Auto-approve most actions (for experienced users) |
| Custom | Define your own rules per tool and per path pattern |
Permission rules are stored locally on your phone and sent to the bridge for enforcement. They're never uploaded anywhere.
How This Compares
Most developer tools collect some amount of data. Here's how Broski's approach is different:
| Aspect | Typical Dev Tool | Broski |
|---|---|---|
| Architecture | Cloud-hosted backend | Peer-to-peer (your devices only) |
| Code access | Code passes through vendor servers | Code never leaves your machine |
| Analytics | Usage tracking, session recordings | Zero analytics, zero tracking |
| Crash reporting | Automatic error reporting | None (email us if something breaks) |
| Data storage | Vendor databases | Your device only (encrypted) |
| Server trust | Trust the vendor's infrastructure | You run the server yourself |
Verify It Yourself
You don't have to take our word for it. The bridge runs on your machine, and you can verify everything:
- •Inspect network traffic — Use Wireshark or Charles Proxy. You'll see encrypted WebSocket frames between your phone and your system, and nothing going to any Broski endpoint.
- •Run the doctor —
broski doctorruns 30+ diagnostics including TLS cert validity, token status, port bindings, and daemon health. - •Check DNS queries — Monitor outgoing DNS. The bridge only resolves your local network addresses and Tailscale endpoints.
Quick Answers
“Can Broski read my code?”
Broski the company? No. The Broski app on your phone? Only what you explicitly open in the file browser or what the AI agent sends during a session. All of this stays between your phone and your system.
“What if someone finds my bridge on the network?”
They'd need your auth token (192 bits of entropy) to connect. Without it, the bridge rejects the connection at the HTTP level before any data is exchanged. The token is validated using constant-time comparison to prevent timing attacks.
“Do you sell data?”
We don't have data to sell. We don't collect analytics, we don't track usage, we don't store conversations. Our revenue comes from subscriptions, not data.
“What happens if I cancel my subscription?”
Your pairing data is preserved. If you resubscribe later, the app automatically reconnects to your system without needing to rescan the QR code. We don't hold your data hostage or delete anything when you leave.
“How do I delete everything?”
Phone: Settings > Clear Cache removes all cached data. Uninstalling removes everything.
System: Delete ~/.broski to remove all bridge data (token, certs, config).
That's it. There's nothing on our end to delete because we never had it.