Automation & Tools

Tailcat: Netcat Over Tailscale's Data Plane, No Account Required

Tailcat pipes data, files and SSH sessions between two machines over WireGuard, punches through NAT and falls back to a relay, with no account, no root and no control plane. I tested it between two boxes, inside containers and with UDP blocked.

Tony Mattke · 2026.11.19 · 10 min read

Tailcat is one binary that connects two machines over an encrypted WireGuard tunnel without a VPN account, an admin login, root, or a port forward. One side runs tailcat and gets back an address that starts with tc. The other side hands that address to tailcat and they’re connected, through whatever NAT sits between them. Pipe text through it like netcat, copy files, forward ports, or get a shell.

Tailscale released it on August 31, 2026, in a post by Brad Fitzpatrick titled “Tailscale without Tailscale, by Tailscale.” His TailscaleUp 2026 session covers the same ground in eleven minutes, with a live demo and a Minecraft mod from his colleague Murad that shares a world without a separate Tailscale install. It’s built from the same pieces as Tailscale’s own client… WireGuard for encryption, the NAT traversal code Tailscale calls magicsock, and Tailscale’s DERP relays as the meeting point and the fallback path. What it leaves out is the control plane, the coordination service that normally hands out keys and decides who can talk to whom. In tailcat, that job belongs to you and the address.

Tailcat is open source under the BSD 3-Clause license. I tested v0.7.0, the current release, between alpha and bravo, two Linux boxes on my home network, and then inside Docker containers to get NAT and a blocked UDP path into the picture.

What’s in an address

The server picks a key pair, picks a DERP relay region, and folds everything a client needs into the address. tailcat parse decodes one without connecting to anything.

tailcat parse, keys shortened
$ tailcat parse tcpGFwWCDLIlqW8ADBTmo7Pz...
{
    "ServerPublic": "nodekey:cb225a96f000c14e...",
    "ServerDiscoPublic": "discokey:37a6bb7191874...",
    "PresharedKey": "psk:27f0c8276389286cbdc...",
    "RegionID": 301
}

The server’s public key tells the client who it’s talking to. The region tells it which relay to meet at, 301 being New York City here. The pre-shared key is a second WireGuard secret on top of the key pair, and it’s why the address itself works as a credential. Anyone holding the full address can complete the handshake.

By default the server generates a new key every run, so the address dies when the process exits. tailcat genkey saves a key to disk for an address that survives restarts, which also means everyone you ever gave that address to can use it again later.

Install

The project ships static binaries, .deb and .rpm packages, Homebrew (macOS), Scoop (Windows), Snap, Nix, AUR, conda-forge and a container image. I used Go on alpha, then copied the binary to bravo.

alpha
$ go install github.com/tailscale/tailcat/cmd/tailcat@latest
$ tailcat version
v0.7.0

The container image (ghcr.io/tailscale/tailcat:latest) also ran unchanged as a server on bravo, and its version printed the same v0.7.0.

The netcat part

On bravo, run tailcat with no arguments. It picks a relay region, prints an address and waits for one connection.

bravo
$ tailcat
# Selected bootstrap relay region 301, New York City
# 🐈 Server listening with new address: tcpGFwWCCr_8sLzbZuXO2ix1jhfJKmcjZWWm00E_GC7Wdwl3pwK2FrWCDkDxorjeH3P...

The address is 154 characters long, so plan on pasting it. On alpha, pipe something into it.

alpha
$ time (echo "hello from alpha" | tailcat tcpGFwWCCr_8sLz...)

real	0m0.522s

Half a second, start to finish, including the WireGuard handshake. Bravo printed hello from alpha and exited.

For something bigger, I sent 500 MiB of random data the same way and checked it on both ends.

500 MiB, alpha to bravo
$ time tailcat tcpGFwWCCjLM-pxSt3K... < big.bin

real	0m5.524s
$ sha256sum big.bin
910ee7fe55413979cbe389842a072c4aad7b101c594b787096e1a1a30edd958a  big.bin
bravo
$ sha256sum file.out
910ee7fe55413979cbe389842a072c4aad7b101c594b787096e1a1a30edd958a  file.out

The transfer ran at about 760 Mbit/s, and the hashes matched. Plain ssh bravo "cat > /dev/null" < big.bin over the same LAN took 5.6 seconds, so the tunnel cost nothing measurable between two boxes on a gigabit network.

tailcat ssh

Tailcat has an SSH server built in, and the client side wraps your normal ssh command. There are two modes.

No auth, the address is the key

bravo
$ tailcat serve no-auth-ssh
# Selected bootstrap relay region 301, New York City
# ⚠️ WARNING: no-auth-ssh gives a shell to anyone with this address; keep it secret (never in a DNS TXT record) or restrict clients with --allow
# 🐈 Server listening with new address: tcpGFwWCDLIlqW8ADBTmo7Pz...
alpha
$ time tailcat ssh tcpGFwWCDLIlqW8ADBTmo7Pz... "hostname; whoami; uptime"
bravo
tonhe
 00:05:34 up 41 days,  4:14,  2 users,  load average: 7.34, 7.03, 6.98

real	0m0.255s

A quarter of a second from a cold start to running commands on another machine, with no account on either side, no port opened anywhere and no host key prompt. The prompt is missing on purpose. tailcat ssh runs the system ssh client with a ProxyCommand that routes through tailcat, and it turns off host key checking, because the server’s identity is already pinned by the WireGuard key inside the address. A server without that private key can’t complete the handshake.

Whoever has this address gets a shell as the user who started the server.

Key auth, like normal SSH

The ssh service makes clients present an SSH key. --ssh-authorized-keys takes an authorized_keys file, literal public key lines, or a GitHub username.

bravo, trusting its own authorized_keys
$ tailcat serve --ssh-authorized-keys=$HOME/.ssh/authorized_keys ssh
alpha, whose key is in that file
$ time tailcat ssh tcpGFwWCAVaGxVfxjGtB6DGb... hostname
bravo

real	0m0.246s

The same address from a container with no SSH keys of its own got through the tunnel and was turned away at the SSH layer.

Container on alpha, no keys
$ tailcat ssh tcpGFwWCAVaGxVfxjGtB6DGb... hostname
root@tailcat-6e8345411d17028c: Permission denied (publickey).

The GitHub form fetches https://github.com/<user>.keys once at startup. Pointed at the README’s own example, bradfitz@github, the server loaded that account’s keys and started. My alpha key isn’t one of them, so it was turned away.

bravo, then alpha
$ tailcat serve --ssh-authorized-keys=bradfitz@github ssh
# 🐈 Server listening with new address: tcpGFwWCCszlLY80iIO6Abyp...

$ tailcat ssh tcpGFwWCCszlLY80iIO6Abyp... hostname
tonhe@tailcat-3e15400d3629f153: Permission denied (publickey).

Locking the tunnel itself

The second lock sits one layer down. --allow limits which client WireGuard keys the server will talk to at all. The client makes a key once and hands over the public half.

alpha
$ tailcat genkey --client --key=lab-client
# wrote file to /home/tonhe/.config/tailcat/keys/lab-client.private.json
nodekey:9f9402466864d2866dd0c272104c229a4b05172c083bdd2391e81c11fa24d701
bravo
$ tailcat serve --allow=nodekey:9f9402466864... no-auth-ssh

The no-auth-ssh warning disappeared from the server’s output this time, since the address alone no longer gets anyone in. From alpha, the allowed key connected in 0.238 seconds. A fresh, unknown key with the exact same address got nothing back.

alpha, a stranger holding the address
$ time tailcat --key=new ssh tcpGFwWCDDz-F8ejXabd... hostname
2026/11/13 00:07:11 tailcat Ping: context deadline exceeded

real	0m10.028s

The server log didn’t show a single line about it. Ignored handshakes get no reply, so a stranger can’t confirm a server is there at all. The two locks are independent, so you pick how many to use.

SettingWho gets a shell
serve no-auth-sshAnyone with the address
serve --allow=<client key> no-auth-sshOnly that client key
serve --ssh-authorized-keys=... sshAnyone with the address and a listed SSH key
Both --allow and --ssh-authorized-keysOnly that client key, holding a listed SSH key

Tailcat can publish an address in a DNS TXT record (tailcat=tc...), so tailcat ssh my-server.example.com works. A TXT record is public, though, so a published address can’t be the credential. The README is blunt that the server behind one needs --allow, SSH key auth or both. The client backs that up. Before connecting to a DNS name, tailcat ssh tries a login the way a stranger would, with a throwaway key and no SSH credentials, and refuses to go on if it works.

Compare that with Tailscale SSH, where who can log in to what comes from your tailnet’s access policy, delivered by the control plane. Tailcat has no control plane and no policy file. The address, the --allow list and the SSH keys are the entire access policy, and you write each one on the command line.

Behind NAT, and when the direct path is blocked

Every connection starts through the DERP relay named in the address, and then both sides try to find a direct UDP path. tailcat ping shows which one each reply took.

Container on alpha (behind Docker's NAT) to bravo
$ tailcat ping --until-direct tcpGFwWCAVaGxVfxjGtB6DGb...
pong in 65.39ms via DERP(nyc)
pong in 730µs via 198.19.0.99:41939

The first reply came the long way through New York, and the second came straight across the LAN, even though the container sits behind Docker’s NAT.

To force the fallback, I blocked all outbound UDP in a client container except DNS, which leaves DERP (it runs over HTTPS) as the only way out.

Client container with UDP blocked
$ iptables -A OUTPUT -p udp --dport 53 -j ACCEPT; iptables -A OUTPUT -p udp -j DROP
$ tailcat ping --until-direct tcpGFwWCB...
pong in 67.56ms via DERP(nyc)
pong in 67.05ms via DERP(nyc)
...
pong in 65.42ms via DERP(nyc)
2026/11/13 00:07:31 no direct path to the server after 10s

Everything still worked, only slower. tailcat ssh ... hostname took 0.91 seconds instead of a quarter of one. A 20 MiB file took 8.9 seconds, roughly 19 Mbit/s, against the 760 Mbit/s of the direct path. The README says Tailscale’s public tailcat relays are rate limited.

One setup never went direct. With the server in a container on bravo and the client in a container on alpha, the path stayed on DERP for a full 30 seconds of trying. The server’s verbose log showed why. The only addresses it had to offer were its container address, which alpha can’t reach, and my house’s public IP, which only works from inside the house if the router loops the traffic back around. Mine apparently doesn’t, so every packet went through the relay.

Files

tailcat recv turns a directory into a drop box, and tailcat cp sends to it with your system scp.

bravo
$ tailcat recv ~/tailcat-test/inbox
# Serving files from /home/tonhe/tailcat-test/inbox (flat write-only)
alpha
$ time tailcat cp hundred.bin tcpGFwWCBi20x0oj6gHM3SbWR7...:

real	0m1.524s

$ tailcat ls tcpGFwWCBi20x0oj6gHM3SbWR7...
.: permission denied

100 MiB in a second and a half, hashes matching. The drop box is write only, so a sender can’t list it or read anything back, and the file landed under a server chosen name (hundred.20261113000922.398c66b42fb00e9b.bin) so a sender can’t overwrite or probe for existing files. tailcat serve files does the opposite and offers a directory for download over SFTP.

What it doesn’t promise

  • No stability promise. The README says tailcat “comes with no API or CLI stability promises: the Go API, the CLI flags and output, and the wire format may all change.” It went from v0.1.0 to v0.7.0 between August 30 and September 19.
  • The free relays are best effort. Per the same README, Tailscale’s public tailcat DERP relays “have no uptime SLAs or throughput targets,” and access can be revoked “at any time, for any reason.” You can run your own DERP server and point tailcat at it.
  • The threat model is young. SECURITY.md says tailcat “was originally designed for use with oneself: the same person running both ends,” and asks you to be careful about serving shells, writable directories or exit nodes to people you don’t trust.
  • You move the address yourself. There’s no directory and no invite flow. The address goes over Slack, email, a text message or a DNS record, so whatever channel you use is part of your security.
  • The browser demo is relay only. The browser version (compiled to WebAssembly) sends everything through DERP until WebRTC support lands.

If I need a shell on a box behind somebody else’s NAT for an afternoon, or a file moved between two machines that can’t see each other, tailcat connects in about a quarter second, needs nothing opened on the network, and leaves nothing open afterward. When the server process exits, an ephemeral address stops working and nobody can connect with it.

Comments