chisel Documentation

Chisel

Chisel is a fast TCP/UDP tunnel, transported over HTTP, secured via SSH. Single executable including both client and server. Written in Go (golang). Chisel is mainly useful for passing through firewalls, though it can also be used to provide a secure endpoint into your network.

Table of Contents Copy Chapter

• Features
• Install
• Demo
• Usage
• Contributing
• Changelog
• License

Features Copy Chapter

• Easy to use
• Performant*
• Encrypted connections using the SSH protocol (via crypto/ssh)
• Authenticated connections; authenticated client connections with a users config file, authenticated server connections with fingerprint matching.
• Client auto-reconnects with exponential backoff (tunable via --min/max-retry-interval); keepalive pings time out, so silently dead connections (sleep/wake, NAT timeouts, server restarts) are detected and re-established
• Clients can create multiple tunnel endpoints over one TCP connection
• Clients can optionally pass through SOCKS or HTTP CONNECT proxies
• Reverse port forwarding (Connections go through the server and out the client)
• Server optionally doubles as a reverse proxy
• Server optionally allows SOCKS5 connections (See guide below)
• Clients optionally allow SOCKS5 connections from a reversed port forward
• Client connections over stdio which supports ssh -o ProxyCommand providing SSH over HTTP

Install Copy Chapter

Binaries Copy Section

See the latest release or download and install it now with curl https://i.jpillora.com/chisel! | bash

Binaries are built with the latest Go release, which sets the minimum OS versions: Windows 10 / Server 2016, macOS 12, Linux kernel 3.2, FreeBSD 12.2. For older systems (e.g. Windows 7), use release v1.8.1 or earlier.

Docker Copy Section

docker run --rm -it jpillora/chisel --help

Images are multi-arch and published to both Docker Hub (jpillora/chisel) and GitHub Container Registry (ghcr.io/jpillora/chisel).

Fedora Copy Section

The package is maintained by the Fedora community. If you encounter issues related to the usage of the RPM, please use this issue tracker.

sudo dnf -y install chisel

Source Copy Section

$ go install github.com/jpillora/chisel@latest

Demo Copy Chapter

You can run your own demo server in minutes (the old Heroku demo went away with Heroku's free tier). example/fly.toml deploys this chisel server to fly.io's free allowance:

$ chisel server --port $PORT --backend http://example.com
# listens on $PORT, proxies normal web requests to http://example.com

Deploy it with fly launch --copy-config from the example/ directory, then tunnel to any service running beside the server, e.g.:

$ chisel client https://<your-app>.fly.dev 3000
# connects to your chisel server,
# tunnels your localhost:3000 to the server's localhost:3000

Visiting your app's URL in a browser hits the server's default backend proxy and shows a copy of example.com.

Usage Copy Chapter

$ chisel --help

  Usage: chisel [command] [--help]

  Version: X.Y.Z

  Commands:
    server - runs chisel in server mode
    client - runs chisel in client mode

  Read more:
    https://github.com/jpillora/chisel

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

Security Copy Section

Encryption is always enabled. When you start up a chisel server, it will generate an in-memory ECDSA public/private key pair. The public key fingerprint (base64 encoded SHA256) will be displayed as the server starts. Instead of generating a random key, the server may optionally specify a key file, using the --keyfile option. When clients connect, they will also display the server's public key fingerprint. The client can force a particular fingerprint using the --fingerprint option. Legacy MD5 fingerprints are still accepted but must be the full 16-octet colon form — truncated prefixes are rejected. See the --help above for more information.

The server also caps inbound websocket message sizes before authentication (CHISEL_WS_READ_LIMIT, default 512 KiB), so unauthenticated peers cannot exhaust memory with oversized messages. The default sits comfortably above x/crypto/ssh's 256 KiB maximum transport packet, so no valid SSH packet is ever rejected. Only 0 disables the limit; negative values fall back to the safe default.

Authentication Copy Section

Using the --authfile option, the server may optionally provide a user.json configuration file to create a list of accepted users. The client then authenticates using the --auth option. See users.json for an example authentication configuration file. See the --help above for more information.

Notes on authfile behavior:

• The file is watched and reloaded live — including editor saves via rename (vim) and kubernetes configmap updates. Reloads apply to new connections and to new tunnels of already-connected clients; removed users lose access to new tunnels immediately, though established tunnels are not interrupted.
• Address patterns are regular expressions and are not anchored — anchor them with ^ and $ (the server warns about unanchored patterns at load). The empty string "" matches everything.
• SOCKS5 access is controlled by an entry matching the token socks. Breaking: SOCKS5 previously bypassed the authfile entirely; servers running --socks5 with --authfile must grant socks to users who should keep proxy access (wildcard "" entries keep working).
• Auth strings without a colon (user:pass) are now a fatal startup error on both server and client — previously they silently disabled authentication.
• The --auth user survives authfile reloads and wins name clashes with file users.

Internally, this is done using the Password authentication method provided by SSH. Learn more about crypto/ssh here http://blog.gopheracademy.com/go-and-ssh/. Session opens/closes (with user, source address and remotes) and failed login attempts are logged at info level.

TLS Guide Copy Section

The simplest secure setup is --tls-domain, which provisions a LetsEncrypt certificate automatically (requires port 443 and a DNS record pointing at the server):

chisel server --port 443 --tls-domain chisel.example.com --auth user:pass
chisel client --auth user:pass https://chisel.example.com R:2222:localhost:22

To use your own certificate (self-signed or internal CA), generate a key/cert pair and point both sides at the right files:

chisel server --port 443 --tls-key key.pem --tls-cert cert.pem
chisel client --tls-ca ca.pem https://chisel.example.com 3000

For mutual TLS, also pass --tls-ca to the server and --tls-cert/--tls-key to each client. Note that TLS wraps chisel's transport from the outside; the inner SSH layer still encrypts and authenticates, so --fingerprint validation works with or without TLS.

SOCKS5 Guide with Docker Copy Section

1. Print a new private key to the terminal

   sh Copy

   chisel server --keygen -
   # or save it to disk --keygen /path/to/mykey

2. Start your chisel server

   sh Copy

   jpillora/chisel server --keyfile '<ck-base64 string or file path>' -p 9312 --socks5

3. Connect your chisel client (using server's fingerprint)

   sh Copy

   chisel client --fingerprint '<see server output>' <server-address>:9312 socks

4. Point your SOCKS5 clients (e.g. OS/Browser) to:

   text Copy

   <client-address>:1080

5. Now you have an encrypted, authenticated SOCKS5 connection over HTTP

Note: if the server also uses --authfile, users need an entry matching the token socks to use the proxy (see Authentication).

Reverse SOCKS with an Authfile Copy Section

To let a specific client act as a SOCKS exit node, grant it the reverse-socks listener address (R:socks listens on the server's 127.0.0.1:1080):

{
  "exituser:password": ["^R:127\\.0\\.0\\.1:1080$"]
}

chisel server --reverse --authfile users.json
chisel client --auth exituser:password <server-address> R:socks
# server-side consumers point SOCKS5 clients at 127.0.0.1:1080,
# and their traffic exits via the chisel client's network

See also the step-by-step reverse tunneling example.

Running behind a CDN (Cloudflare) Copy Section

chisel works through CDNs that support WebSockets. For Cloudflare: enable WebSockets, proxy (orange-cloud) the DNS record, and connect clients with https://. The CDN terminates TLS, but the inner SSH layer means --fingerprint validation still authenticates your chisel server end-to-end — the CDN cannot read or modify tunneled traffic. Keep --keepalive at its 25s default to stay under CDN idle timeouts, and note that proxies which strip Upgrade headers cannot carry chisel at all.

Tuning with environment variables Copy Section

Less common knobs are environment variables, all read with a CHISEL_ prefix (e.g. CHISEL_WS_TIMEOUT=10s):

HOST, PORT, AUTH, and CHISEL_KEY/CHISEL_KEY_FILE are documented in the --help texts above.

Caveats

Since WebSockets support is required:

• IaaS providers all will support WebSockets (unless an unsupporting HTTP proxy has been forced in front of you, in which case I'd argue that you've been downgraded to PaaS)
• PaaS providers vary in their support for WebSockets
  • Heroku has full support
  • Openshift has full support though connections are only accepted on ports 8443 and 8080
  • Google App Engine standard has no support (the flexible environment does)

Contributing Copy Chapter

• http://golang.org/doc/code.html
• http://golang.org/doc/effective_go.html
• github.com/jpillora/chisel/share contains the shared package
• github.com/jpillora/chisel/server contains the server package
• github.com/jpillora/chisel/client contains the client package

Changelog Copy Chapter

• 1.0 - Initial release
• 1.1 - Replaced simple symmetric encryption for ECDSA SSH
• 1.2 - Added SOCKS5 (server) and HTTP CONNECT (client) support
• 1.3 - Added reverse tunnelling support
• 1.4 - Added arbitrary HTTP header support
• 1.5 - Added reverse SOCKS support (by @aus)
• 1.6 - Added client stdio support (by @BoleynSu)
• 1.7 - Added UDP support
• 1.8 - Move to a scratchDocker image
• 1.9 - Bump to Go 1.21. Switch from --key seed to P256 key strings with --key{gen,file} (by @cmenginnz)
• 1.10 - Bump to Go 1.22. Add .rpm .deb and .apk to releases. Fix bad version comparison.
• 1.11 - Bump to Go 1.25.1. Update all dependencies.
• 1.12 - (unreleased) Reliability and security pass:
  • keepalive pings now time out (CHISEL_PING_TIMEOUT), so dead connections reconnect promptly after sleep/wake, NAT timeouts and server restarts
  • authfile reloads survive editor renames and kubernetes configmap swaps, and apply live to connected clients (new tunnels; established tunnels are not interrupted)
  • breaking: with --socks5 + --authfile, SOCKS5 access now requires an authfile entry matching socks (wildcard "" entries keep working)
  • breaking: truncated legacy MD5 fingerprints are rejected — --fingerprint must be the full SHA256 form (or the full 16-octet MD5 colon form)
  • breaking: auth strings without a colon (e.g. --auth user) are a fatal startup error instead of silently disabling authentication
  • TCP half-close is propagated through tunnels, and unreachable targets reject the tunnel instead of presenting a dead connection (CHISEL_DIAL_TIMEOUT, default 30s)
  • graceful shutdown on SIGTERM with HTTP request draining (CHISEL_SHUTDOWN_GRACE); a second signal force-exits
  • UDP exit nodes no longer break or leak past 100 concurrent flows (CHISEL_UDP_MAX_CONNS)
  • inbound websocket messages are size-capped pre-auth (CHISEL_WS_READ_LIMIT)
  • server no longer panics when a client disconnects between the SSH handshake and its config request (#608)
  • client exits non-zero when --max-retry-count is exhausted; new --min-retry-interval (default 1s); socks5:// accepted for --proxy
  • go install builds report their real version; sessions and failed logins are logged at info level
  • releases now ship goreleaser-built multi-arch Docker images to GHCR and Docker Hub with correctly stamped versions; releasing is two-stage — tagging builds a draft GitHub release plus version-tagged images, and publishing the draft promotes the Docker latest / X / X.Y tags

Upgrading to 1.12 Copy Section

Four changes may require action when upgrading from 1.11.x or earlier:

1. SOCKS5 + --authfile (enforced since v1.11.7): users who should keep proxy access need an authfile entry matching the token socks (the wildcard "" keeps working). See Authentication. Denied requests are logged server-side as Denied connection to socks (ACL).
2. --fingerprint: truncated legacy MD5 fingerprints are rejected. Use the full SHA256 fingerprint printed by the server and client (the full 16-octet MD5 colon form is still accepted, but deprecated).
3. --auth values must be : — strings without a colon now fail at startup instead of silently disabling authentication.
4. Exit codes: chisel client with --max-retry-count now exits non-zero when connection attempts are exhausted; scripts checking $? and systemd Restart=on-failure units will notice.

License Copy Chapter

MIT © Jaime Pillora