Files
James Tucker f55fd4e9e4 util/cpucaps, tsweb/varz: extract and extend GOAMD64 and CPU capability detection
Move the goamd64_capable/goamd64_compiled logic out of tsweb/varz
into a new util/cpucaps package so that a future hostinfo extension
can share it, and extend it to all supported platforms.

The host GOAMD64 level is now computed from CPUID feature bits via
x/sys/cpu rather than by parsing /proc/cpuinfo, which removes the
linux/amd64 restriction and all file I/O. CPUID is also what the Go
runtime checks at startup, so it directly answers the question the
metric asks: could this machine run a binary built at a higher level.

Four flags required by the runtime checks have no x/sys/cpu field:
LAHF/SAHF (v2) and MOVBE, LZCNT and F16C (v3). We report a level when
all of its other flags are present. That is exact on real hardware:
LAHF/SAHF exists on every 64-bit CPU that also has SSE4.2, and
MOVBE/LZCNT/F16C exist on every CPU that also has AVX2, BMI2 and FMA
(Haswell and Zen onwards). A linux/amd64 test cross-checks the CPUID
result against the exact /proc/cpuinfo flag lists, so a test run on
any machine where the assumption fails, or where the kernel's view
diverges from CPUID (e.g. clearcpuid=), reports the difference.

Add a Caps bitmask of the CPU capabilities that Go's runtime and
standard library dispatch on, normalized across amd64 and arm64: AES,
CLMUL/PMULL, SHA2, SHA512, CRC32, ADX and LSE, plus the vector
capabilities not implied by the GOAMD64 level: AVX, AVX2, AVX512 (the
v4 F+BW+CD+DQ+VL subset), VAES, VPCLMULQDQ and GFNI. Detection is
lazy and reads only x/sys/cpu globals and build info; there is no
init-time work and no new dependency.

Coverage includes all key client platforms: linux, windows, darwin,
freebsd, android (via the linux auxv/MRS path in x/sys/cpu) and ios
(via the darwin sysctl path). x/sys/cpu has no arm64 detection on
FreeBSD, so read ID_AA64ISAR0_EL1 directly; the FreeBSD kernel
emulates EL0 reads of the ID registers, and Go's runtime already
depends on that emulation on this platform.

The whole feature is behind a new cpucaps feature tag. Building with
ts_omit_cpucaps removes the varz metrics and all detection code
following the tka stub pattern: the detection functions compile to
stubs returning zero inside the package itself, so future importers
cannot reintroduce the code by forgetting a build tag, and the Caps
type stays available for decoding recorded values. A tailscaled
dependency test enforces the omission, and the generated
buildfeatures.HasCPUCaps const is available for the later hostinfo
extension.

tsweb/varz metric names are unchanged. gauge_goamd64_capable values
only change on machines where /proc/cpuinfo disagrees with CPUID.

Updates #21002

Signed-off-by: James Tucker <[email protected]>
2026-08-26 18:31:31 -07:00
..
2026-07-10 17:39:16 -07:00

tsnet

Go Reference

Package tsnet embeds a Tailscale node directly into a Go program, allowing it to join a tailnet and accept or dial connections without running a separate tailscaled daemon or requiring any system-level configuration.

Overview

Normally, Tailscale runs as a background system service (tailscaled) that manages a virtual network interface for the whole machine. tsnet takes a different approach: it runs a fully self-contained Tailscale node inside your process using a userspace TCP/IP stack (gVisor). This means:

  • No root privileges required.
  • No system daemons to install or manage.
  • Multiple independent Tailscale nodes can run within a single binary.
  • The node's Tailscale identity and state are stored in a directory you control.

The core type is Server, which represents one embedded Tailscale node. Calling Server.Listen or Server.Dial routes traffic exclusively over the tailnet. The standard library's net.Listener and net.Conn interfaces are returned, so any existing Go HTTP server, gRPC server, or other net-based code works without modification.

Usage

import "tailscale.com/tsnet"

s := &tsnet.Server{
	Hostname: "my-service",
	AuthKey:  os.Getenv("TS_AUTHKEY"),
}
defer s.Close()

ln, err := s.Listen("tcp", ":80")
if err != nil {
	log.Fatal(err)
}
log.Fatal(http.Serve(ln, myHandler))

On first run, if no Server.AuthKey is provided and the node is not already enrolled, the server logs an authentication URL. Open it in a browser to add the node to your tailnet.

Authentication

A Server authenticates using, in order of precedence:

  1. Server.AuthKey.

  2. The TS_AUTHKEY environment variable.

  3. The TS_AUTH_KEY environment variable.

  4. An OAuth client secret (Server.ClientSecret or TS_CLIENT_SECRET), used to mint an auth key.

  5. Workload identity federation (Server.ClientID plus Server.IDToken or Server.Audience). Available only if the program imports the feature:

    import _ "tailscale.com/feature/identityfederation"

    The feature is not linked by default to keep the AWS SDK and other cloud-provider dependencies out of programs that don't use workload identity federation.

  6. An interactive login URL printed to Server.UserLogf.

If the node is already enrolled (state found in Server.Store), the auth key is ignored unless TSNET_FORCE_LOGIN=1 is set.

Identifying callers

Use the WhoIs method on the client returned by Server.LocalClient to identify who is making a request:

lc, _ := srv.LocalClient()
http.Serve(ln, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	who, err := lc.WhoIs(r.Context(), r.RemoteAddr)
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
	fmt.Fprintf(w, "Hello, %s!", who.UserProfile.LoginName)
}))

Tailscale Funnel

Server.ListenFunnel exposes your service on the public internet. Tailscale Funnel currently supports TCP on ports 443, 8443, and 10000. HTTPS must be enabled in the Tailscale admin console.

ln, err := srv.ListenFunnel("tcp", ":443")
// ln is a TLS listener; connections can come from anywhere on the
// internet as well as from your tailnet.

// To restrict to public traffic only:
ln, err = srv.ListenFunnel("tcp", ":443", tsnet.FunnelOnly())

Tailscale Services

Server.ListenService advertises the node as a host for a named Tailscale Service. The node must use a tag-based identity. To advertise multiple ports, call ListenService once per port.

srv.AdvertiseTags = []string{"tag:myservice"}

ln, err := srv.ListenService("svc:my-service", tsnet.ServiceModeHTTP{
	HTTPS: true,
	Port:  443,
})
log.Printf("Listening on https://%s", ln.FQDN)

Using an exit node

A tsnet node can route its Server.Dial traffic to non-tailnet addresses through an exit node. Select the exit node by setting the ExitNodeID pref via Server.LocalClient:

lc, _ := srv.LocalClient()
_, err := lc.EditPrefs(ctx, &ipn.MaskedPrefs{
	Prefs:         ipn.Prefs{ExitNodeID: "nodeid"},
	ExitNodeIDSet: true,
})

Dials of addresses outside the tailnet then go through the exit node. Dials within the tailnet are unaffected.

Running multiple nodes in one process

Each Server instance is an independent node. Give each a unique Server.Dir and Server.Hostname:

for _, name := range []string{"frontend", "backend"} {
	srv := &tsnet.Server{
		Hostname:  name,
		Dir:       filepath.Join(baseDir, name),
		AuthKey:   os.Getenv("TS_AUTHKEY"),
		Ephemeral: true,
	}
	srv.Start()
}