feat: add control center, multiple relay nodes and P2P-first transport

This commit is contained in:
tongtong committed 2026-11-12 16:56:06 +08:00
1 parent 0988e9c363
commit 2abfb63da9
44 files changed
+3477 -67

No files matched your search

+10 -9
View File
@@ -1,12 +1,13 @@
# ads-server(Go 公网服务器)
# ADS 控制中心与中继(Go)
入口:`main.go`。独立构建:`go build -o ads-server .`。
`main.go` / `cluster.go` 是 ads-server 控制中心。`go build -o ads-server .`。
配置 ADS_AGENT_TOKEN、ADS_CLIENT_TOKEN(不同且至少 32 字符);默认回环监听,可用 --listen 修改。
- 配置:环境变量 `ADS_AGENT_TOKEN`、`ADS_CLIENT_TOKEN`,要求不同且各至少 32 字符。
- 默认监听:`127.0.0.1:8080`,用 `--listen` 修改。
- TLS:反向代理或 `--tls-cert` 与 `--tls-key`;公网必须使用有效证书。
- 路由:`/healthz`、`/v1/agent`、`/v1/devices`、`/v1/lease`、`/v1/connect`、`/v1/data`。
- 状态存内存;一个 ID 对应一个在线 agent,一个设备对应一个独占租约。
- Ctrl+C / SIGTERM 关闭控制与数据连接;两端支持重连。
加上 `--cluster-config /etc/ads/cluster.json` 和至少 32 字符的 ADS_RELAY_SECRET 启用 v2:控制中心负责注册、独占租约、SDP 信令与节点健康,不转发 v2 ADB 数据。未配置集群则保留 v1 数据转发。公网使用有效证书或 HTTPS 反向代理。
部署、令牌配置和三端完整命令见项目根目录 `README.md`。
| 内部目录 | 用途 | 语言 |
| --- | --- | --- |
| `cmd/ads-relay/` | 独立节点入口,`go build -o ads-relay ./cmd/ads-relay` | Go |
| `internal/relay/` | HMAC 票据、WSS 配对、撤销、可选 STUN 和测试 | Go |
集群配置、角色、协议及部署见 [集群说明](../docs/cluster.md)。执行 `go test -race ./...` 检查并发行为。
+343
View File
@@ -0,0 +1,343 @@
package main
import (
"bytes"
"context"
"crypto/subtle"
"crypto/tls"
"encoding/json"
"errors"
"io"
"net"
"net/http"
"net/url"
"os"
"sort"
"strings"
"sync"
"sync/atomic"
"time"
"android-device-streaming/server/internal/relay"
"github.com/coder/websocket"
)
type NodeConfig struct {
ID string `json:"id"`
URL string `json:"url"`
ConnectAddress string `json:"connect_address,omitempty"`
Priority int `json:"priority"`
}
type clusterConfig struct {
Nodes []NodeConfig `json:"nodes"`
ICEServers []string `json:"ice_servers"`
P2PTimeoutMS int `json:"p2p_timeout_ms"`
}
type nodeHealth struct {
Healthy bool `json:"healthy"`
Sessions int `json:"sessions"`
Capacity int `json:"capacity"`
}
type cluster struct {
config clusterConfig
secret string
mu sync.Mutex
health map[string]nodeHealth
signalingBytes atomic.Int64
}
type route struct {
ID string `json:"id"`
URL string `json:"url"`
ConnectAddress string `json:"connect_address,omitempty"`
Ticket string `json:"ticket"`
}
func loadCluster(path, secret string, allowInsecure bool) (*cluster, error) {
if len(secret) < 32 {
return nil, errors.New("cluster mode requires ADS_RELAY_SECRET (32+ characters)")
}
data, err := os.ReadFile(path)
if err != nil {
return nil, err
}
var config clusterConfig
if err = json.Unmarshal(data, &config); err != nil {
return nil, err
}
if config.ICEServers == nil {
config.ICEServers = []string{}
}
if len(config.Nodes) == 0 || len(config.Nodes) > 32 {
return nil, errors.New("configure 1–32 relay nodes")
}
if config.P2PTimeoutMS == 0 {
config.P2PTimeoutMS = 10000
}
if config.P2PTimeoutMS < 1000 || config.P2PTimeoutMS > 30000 {
return nil, errors.New("p2p_timeout_ms must be 1000–30000")
}
seen := map[string]bool{}
for _, node := range config.Nodes {
u, e := url.Parse(node.URL)
if e != nil || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Scheme != "wss" && !(allowInsecure && u.Scheme == "ws")) || !validID(node.ID) || seen[node.ID] {
return nil, errors.New("invalid or duplicate relay node")
}
if node.ConnectAddress != "" {
if _, _, e = net.SplitHostPort(node.ConnectAddress); e != nil {
return nil, errors.New("invalid node connect_address")
}
}
seen[node.ID] = true
}
for _, ice := range config.ICEServers {
if !strings.HasPrefix(ice, "stun:") {
return nil, errors.New("only STUN URLs are accepted; fallback uses WSS relay nodes")
}
}
return &cluster{config: config, secret: secret, health: map[string]nodeHealth{}}, nil
}
func nodeHTTP(node NodeConfig, path string) (*http.Client, string) {
u, _ := url.Parse(node.URL)
if u.Scheme == "wss" {
u.Scheme = "https"
} else {
u.Scheme = "http"
}
u.Path = strings.TrimRight(u.Path, "/") + path
transport := &http.Transport{TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12}, Proxy: nil}
if node.ConnectAddress != "" {
transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
return (&net.Dialer{Timeout: 3 * time.Second}).DialContext(ctx, network, node.ConnectAddress)
}
}
return &http.Client{Transport: transport, Timeout: 3 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}, u.String()
}
func (c *cluster) monitor(ctx context.Context) {
probe := func() {
var wg sync.WaitGroup
for _, node := range c.config.Nodes {
wg.Add(1)
go func(node NodeConfig) {
defer wg.Done()
client, address := nodeHTTP(node, "/healthz")
defer client.CloseIdleConnections()
req, _ := http.NewRequestWithContext(ctx, "GET", address, nil)
response, err := client.Do(req)
health := nodeHealth{}
if err == nil {
defer response.Body.Close()
var body struct {
ID string `json:"id"`
Sessions int `json:"sessions"`
Capacity int `json:"capacity"`
}
if response.StatusCode == 200 && json.NewDecoder(io.LimitReader(response.Body, 4096)).Decode(&body) == nil && body.ID == node.ID && body.Capacity > 0 {
health = nodeHealth{true, body.Sessions, body.Capacity}
}
}
c.mu.Lock()
c.health[node.ID] = health
c.mu.Unlock()
}(node)
}
wg.Wait()
}
probe()
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
probe()
}
}
}
func (c *cluster) routes(session, lease, side string) []route {
nodes := append([]NodeConfig(nil), c.config.Nodes...)
c.mu.Lock()
sort.SliceStable(nodes, func(i, j int) bool {
a, b := c.health[nodes[i].ID], c.health[nodes[j].ID]
if a.Healthy != b.Healthy {
return a.Healthy
}
if nodes[i].Priority != nodes[j].Priority {
return nodes[i].Priority < nodes[j].Priority
}
return float64(a.Sessions)/float64(max(a.Capacity, 1)) < float64(b.Sessions)/float64(max(b.Capacity, 1))
})
c.mu.Unlock()
result := make([]route, 0, len(nodes))
for _, node := range nodes {
result = append(result, route{ID: node.ID, URL: node.URL, ConnectAddress: node.ConnectAddress,
Ticket: relay.Sign(c.secret, relay.Ticket{Session: session, Lease: lease, Node: node.ID, Side: side, Expires: time.Now().Add(time.Minute).Unix()})})
}
return result
}
func (c *cluster) revoke(lease string) {
if c == nil {
return
}
body, _ := json.Marshal(map[string]string{"lease": lease})
var wg sync.WaitGroup
for _, node := range c.config.Nodes {
wg.Add(1)
go func(node NodeConfig) {
defer wg.Done()
client, address := nodeHTTP(node, "/internal/revoke")
defer client.CloseIdleConnections()
request, _ := http.NewRequest("POST", address, bytes.NewReader(body))
request.Header.Set("Authorization", "Bearer "+c.secret)
request.Header.Set("Content-Type", "application/json")
if response, err := client.Do(request); err == nil {
response.Body.Close()
}
}(node)
}
wg.Wait()
}
func (b *broker) nodesEndpoint(w http.ResponseWriter, r *http.Request) {
if b.cluster == nil {
http.Error(w, "cluster not configured", 404)
return
}
b.cluster.mu.Lock()
defer b.cluster.mu.Unlock()
type node struct {
NodeConfig
nodeHealth
}
nodes := []node{}
for _, configured := range b.cluster.config.Nodes {
nodes = append(nodes, node{configured, b.cluster.health[configured.ID]})
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{"nodes": nodes, "signaling_bytes": b.cluster.signalingBytes.Load(), "data_bytes": 0})
}
func (b *broker) clusterConnectEndpoint(w http.ResponseWriter, r *http.Request) {
if b.cluster == nil {
http.Error(w, "cluster not configured", 404)
return
}
id, leaseID := r.URL.Query().Get("device"), r.URL.Query().Get("lease")
b.mu.Lock()
a, l := b.agents[id], b.leases[id]
if a == nil || !a.v2 || a.ws == nil || l == nil || l.ws == nil || l.id != leaseID {
b.mu.Unlock()
http.Error(w, "no active v2 lease", 409)
return
}
count := 0
for _, s := range b.sessions {
if s.agent == a {
count++
}
}
if count >= 32 {
b.mu.Unlock()
http.Error(w, "stream limit reached", 429)
return
}
ctx, cancel := context.WithCancel(b.ctx)
s := &session{id: newID(), agent: a, lease: l, ready: make(chan *websocket.Conn, 1), ctx: ctx, cancel: cancel, v2: true, signalKey: newID()}
b.sessions[s.id] = s
b.mu.Unlock()
defer func() { cancel(); b.mu.Lock(); delete(b.sessions, s.id); b.mu.Unlock() }()
client, err := accept(w, r)
if err != nil {
return
}
defer client.CloseNow()
publicOnly := r.URL.Query().Get("public_only") == "1"
manifest := func(side string) map[string]any {
return map[string]any{"type": "session", "protocol": 2, "session": s.id,
"ice_servers": b.cluster.config.ICEServers, "p2p_timeout_ms": b.cluster.config.P2PTimeoutMS, "public_only": publicOnly, "routes": b.cluster.routes(s.id, l.id, side)}
}
if writeJSON(ctx, client, manifest("client")) != nil {
return
}
if writeJSON(ctx, a.ws, map[string]any{"type": "open_v2", "session": s.id, "signal_key": s.signalKey}) != nil {
return
}
timer := time.NewTimer(15 * time.Second)
defer timer.Stop()
select {
case peer := <-s.ready:
defer peer.CloseNow()
if writeJSON(ctx, peer, manifest("agent")) != nil {
return
}
b.bridgeSignals(ctx, client, peer)
case <-ctx.Done():
case <-timer.C:
}
}
func (b *broker) signalEndpoint(w http.ResponseWriter, r *http.Request) {
b.mu.Lock()
s := b.sessions[r.URL.Query().Get("session")]
if s == nil || !s.v2 || s.claimed || s.ctx.Err() != nil || b.agents[s.agent.id] != s.agent ||
subtle.ConstantTimeCompare([]byte(s.signalKey), []byte(r.URL.Query().Get("key"))) != 1 {
b.mu.Unlock()
http.Error(w, "invalid signaling ticket", 404)
return
}
s.claimed = true
b.mu.Unlock()
ws, err := accept(w, r)
if err != nil {
s.cancel()
return
}
defer ws.CloseNow()
select {
case s.ready <- ws:
case <-s.ctx.Done():
return
}
<-s.ctx.Done()
}
func (b *broker) bridgeSignals(parent context.Context, a, z *websocket.Conn) {
ctx, cancel := context.WithCancel(parent)
defer cancel()
copyOne := func(dst, src *websocket.Conn) {
defer cancel()
for {
typ, data, err := src.Read(ctx)
if err != nil || typ != websocket.MessageText {
return
}
var message struct {
Type string `json:"type"`
}
if json.Unmarshal(data, &message) != nil {
return
}
switch message.Type {
case "offer", "answer", "relay", "route-ready", "route-error", "p2p-ready":
default:
return
}
deadline, stop := context.WithTimeout(ctx, 10*time.Second)
err = dst.Write(deadline, typ, data)
stop()
if err != nil {
return
}
b.cluster.signalingBytes.Add(int64(len(data)))
}
}
var wg sync.WaitGroup
wg.Add(2)
go func() { defer wg.Done(); copyOne(a, z) }()
go func() { defer wg.Done(); copyOne(z, a) }()
wg.Wait()
}
+110
View File
@@ -0,0 +1,110 @@
package main
import (
"context"
"encoding/json"
"github.com/coder/websocket"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
)
func readV2(t *testing.T, ws *websocket.Conn) map[string]any {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
_, data, err := ws.Read(ctx)
if err != nil {
t.Fatal(err)
}
var result map[string]any
if json.Unmarshal(data, &result) != nil {
t.Fatal("invalid json")
}
return result
}
func TestV2SignalRoleScopeAndPayloadRejection(t *testing.T) {
b, base := testServer(t)
b.cluster = &cluster{secret: strings.Repeat("s", 32), config: clusterConfig{Nodes: []NodeConfig{{ID: "n", URL: "ws://127.0.0.1:1"}}, ICEServers: []string{}, P2PTimeoutMS: 1000}, health: map[string]nodeHealth{}}
for _, path := range []string{"/v2/nodes", "/v2/connect"} {
if got := status(t, base, path, testAgentToken); got != 401 {
t.Fatal(got)
}
}
if got := status(t, base, "/v2/signal", testClientToken); got != 401 {
t.Fatal(got)
}
agent := dialTest(t, base, "/v1/agent?device=phone&v=2", testAgentToken)
readV2(t, agent)
owner := dialTest(t, base, "/v1/lease?device=phone&v=2", testClientToken)
lease := readV2(t, owner)
if lease["protocol"] != float64(2) {
t.Fatal(lease)
}
client := dialTest(t, base, "/v2/connect?device=phone&lease="+lease["lease"].(string), testClientToken)
manifest := readV2(t, client)
open := readV2(t, agent)
if manifest["protocol"] != float64(2) || open["type"] != "open_v2" {
t.Fatal(manifest, open)
}
if got := status(t, base, "/v2/signal?session="+open["session"].(string)+"&key=wrong", testAgentToken); got != 404 {
t.Fatal(got)
}
signal := dialTest(t, base, "/v2/signal?session="+open["session"].(string)+"&key="+open["signal_key"].(string), testAgentToken)
readV2(t, signal)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if err := client.Write(ctx, websocket.MessageText, []byte(`{"type":"offer","sdp":"test"}`)); err != nil {
t.Fatal(err)
}
if readV2(t, signal)["sdp"] != "test" {
t.Fatal("signal not forwarded")
}
if err := client.Write(ctx, websocket.MessageBinary, []byte("adb-payload")); err != nil {
t.Fatal(err)
}
if _, _, err := signal.Read(ctx); err == nil {
t.Fatal("controller accepted binary data")
}
}
func TestSignalBridgeRejectsUnknownMessages(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
b := newBroker(ctx, testAgentToken, testClientToken)
b.cluster = &cluster{}
mux := http.NewServeMux()
var first *websocket.Conn
ready := make(chan struct{})
mux.HandleFunc("/first", func(w http.ResponseWriter, r *http.Request) {
a, e := accept(w, r)
if e != nil {
return
}
defer a.CloseNow()
first = a
close(ready)
<-ctx.Done()
})
mux.HandleFunc("/second", func(w http.ResponseWriter, r *http.Request) {
a, e := accept(w, r)
if e != nil {
return
}
defer a.CloseNow()
<-ready
b.bridgeSignals(ctx, first, a)
})
srv := httptest.NewServer(mux)
defer srv.Close()
a := dialTest(t, srv.URL, "/first", testClientToken)
z := dialTest(t, srv.URL, "/second", testClientToken)
deadline, stop := context.WithTimeout(ctx, time.Second)
defer stop()
a.Write(deadline, websocket.MessageText, []byte(`{"type":"arbitrary"}`))
if _, _, err := z.Read(deadline); err == nil {
t.Fatal("unknown signal accepted")
}
cancel()
}
+3
View File
@@ -0,0 +1,3 @@
# ads-relay
Standalone Go data-plane node. Build from `server/` with `go build -o ../bin/ads-relay ./cmd/ads-relay`. Set `ADS_RELAY_SECRET` to the controller's private signing key, and run behind a TLS reverse proxy. `--id` must match the controller node configuration.
+65
View File
@@ -0,0 +1,65 @@
package main
import (
"android-device-streaming/server/internal/relay"
"context"
"flag"
"log"
"net"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
id := flag.String("id", "relay-1", "Unique node ID")
listen := flag.String("listen", "127.0.0.1:18082", "Listen address behind a WSS reverse proxy")
capacity := flag.Int("capacity", 256, "Maximum concurrent paired streams")
cert := flag.String("tls-cert", "", "TLS certificate path")
key := flag.String("tls-key", "", "TLS private key path")
stunAddress := flag.String("stun-listen", "", "Optional UDP STUN binding address")
flag.Parse()
secret := os.Getenv("ADS_RELAY_SECRET")
if len(secret) < 32 || *id == "" || *capacity < 1 {
log.Fatal("provide a node ID, positive capacity and ADS_RELAY_SECRET (32+ characters)")
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
if *stunAddress != "" {
address, err := net.ResolveUDPAddr("udp", *stunAddress)
if err != nil {
log.Fatal(err)
}
conn, err := net.ListenUDP("udp", address)
if err != nil {
log.Fatal(err)
}
go func() {
if err := relay.ServeSTUN(ctx, conn); err != nil {
log.Printf("STUN stopped: %v", err)
stop()
}
}()
}
node := relay.NewNode(ctx, *id, secret, *capacity)
server := &http.Server{Addr: *listen, Handler: node.Handler(), ReadHeaderTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 * 1024}
go func() {
<-ctx.Done()
node.Close()
shutdown, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
server.Shutdown(shutdown)
}()
log.Printf("relay node %s listening on %s", *id, *listen)
var err error
if *cert != "" && *key != "" {
err = server.ListenAndServeTLS(*cert, *key)
} else {
err = server.ListenAndServe()
}
if err != nil && err != http.ErrServerClosed {
log.Fatal(err)
}
}
+13 -1
View File
@@ -2,4 +2,16 @@ module android-device-streaming/server
go 1.24.0
require github.com/coder/websocket v1.8.14
require (
github.com/coder/websocket v1.8.14
github.com/pion/stun/v3 v3.0.1
)
require (
github.com/pion/dtls/v3 v3.0.7 // indirect
github.com/pion/logging v0.2.4 // indirect
github.com/pion/transport/v3 v3.0.8 // indirect
github.com/wlynxg/anet v0.0.5 // indirect
golang.org/x/crypto v0.32.0 // indirect
golang.org/x/sys v0.29.0 // indirect
)
+24
View File
@@ -1,2 +1,26 @@
github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/pion/dtls/v3 v3.0.7 h1:bItXtTYYhZwkPFk4t1n3Kkf5TDrfj6+4wG+CZR8uI9Q=
github.com/pion/dtls/v3 v3.0.7/go.mod h1:uDlH5VPrgOQIw59irKYkMudSFprY9IEFCqz/eTz16f8=
github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
github.com/pion/stun/v3 v3.0.1 h1:jx1uUq6BdPihF0yF33Jj2mh+C9p0atY94IkdnW174kA=
github.com/pion/stun/v3 v3.0.1/go.mod h1:RHnvlKFg+qHgoKIqtQWMOJF52wsImCAf/Jh5GjX+4Tw=
github.com/pion/transport/v3 v3.0.8 h1:oI3myyYnTKUSTthu/NZZ8eu2I5sHbxbUNNFW62olaYc=
github.com/pion/transport/v3 v3.0.8/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2FPrOYHctQ=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+3
View File
@@ -0,0 +1,3 @@
# Relay internals
Go package implementing short-lived HMAC route tickets, replay/revocation checks, bounded WebSocket stream pairing node health/load counters and optional rate-bounded STUN Binding. Shared by the controller and the standalone node binary. This directory contains Go source; no credentials are stored here.
+204
View File
@@ -0,0 +1,204 @@
package relay
import (
"context"
"crypto/subtle"
"encoding/json"
"io"
"net/http"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/coder/websocket"
)
type pair struct {
lease string
peers map[string]*websocket.Conn
ready chan struct{}
ctx context.Context
cancel context.CancelFunc
expires int64
}
type Node struct {
ID, Secret string
Capacity int
mu sync.Mutex
pairs map[string]*pair
used map[string]int64
revoked map[string]int64
bytes atomic.Int64
ctx context.Context
}
func NewNode(ctx context.Context, id, secret string, capacity int) *Node {
return &Node{ID: id, Secret: secret, Capacity: capacity, ctx: ctx, pairs: make(map[string]*pair), used: make(map[string]int64), revoked: make(map[string]int64)}
}
func (n *Node) cleanupLocked() {
now := time.Now().Unix()
for id, expiry := range n.used {
if expiry <= now {
delete(n.used, id)
}
}
for id, expiry := range n.revoked {
if expiry <= now {
delete(n.revoked, id)
}
}
}
func (n *Node) Handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
n.mu.Lock()
count := len(n.pairs)
n.mu.Unlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{"id": n.ID, "sessions": count, "capacity": n.Capacity, "bytes": n.bytes.Load()})
})
mux.HandleFunc("POST /internal/revoke", n.revoke)
mux.HandleFunc("GET /v2/tunnel", n.tunnel)
return mux
}
func (n *Node) revoke(w http.ResponseWriter, r *http.Request) {
if subtle.ConstantTimeCompare([]byte(r.Header.Get("Authorization")), []byte("Bearer "+n.Secret)) != 1 {
http.Error(w, "unauthorized", 401)
return
}
var body struct {
Lease string `json:"lease"`
}
if json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&body) != nil || body.Lease == "" {
http.Error(w, "bad request", 400)
return
}
n.mu.Lock()
n.cleanupLocked()
n.revoked[body.Lease] = time.Now().Add(2 * time.Minute).Unix()
for _, p := range n.pairs {
if p.lease == body.Lease {
p.cancel()
}
}
n.mu.Unlock()
w.WriteHeader(204)
}
func (n *Node) tunnel(w http.ResponseWriter, r *http.Request) {
ticket, err := Verify(n.Secret, strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "), n.ID, time.Now())
if err != nil {
http.Error(w, "unauthorized", 401)
return
}
n.mu.Lock()
n.cleanupLocked()
key := ticket.Session + ":" + ticket.Side
if n.revoked[ticket.Lease] > 0 || n.used[key] > 0 {
n.mu.Unlock()
http.Error(w, "revoked or replayed ticket", 409)
return
}
p := n.pairs[ticket.Session]
if p == nil {
if len(n.pairs) >= n.Capacity {
n.mu.Unlock()
http.Error(w, "node full", 429)
return
}
ctx, cancel := context.WithCancel(n.ctx)
p = &pair{lease: ticket.Lease, peers: make(map[string]*websocket.Conn), ready: make(chan struct{}), ctx: ctx, cancel: cancel, expires: ticket.Expires}
n.pairs[ticket.Session] = p
}
if p.lease != ticket.Lease || p.ctx.Err() != nil {
n.mu.Unlock()
http.Error(w, "session closed", 409)
return
}
n.used[key] = ticket.Expires
n.mu.Unlock()
defer func() {
p.cancel()
n.mu.Lock()
if n.pairs[ticket.Session] == p {
delete(n.pairs, ticket.Session)
}
n.mu.Unlock()
}()
ws, err := websocket.Accept(w, r, nil)
if err != nil {
p.cancel()
return
}
defer ws.CloseNow()
ws.SetReadLimit(128 * 1024)
n.mu.Lock()
if p.ctx.Err() != nil {
n.mu.Unlock()
return
}
p.peers[ticket.Side] = ws
if len(p.peers) == 2 {
close(p.ready)
}
n.mu.Unlock()
timer := time.NewTimer(15 * time.Second)
defer timer.Stop()
select {
case <-p.ready:
case <-p.ctx.Done():
return
case <-timer.C:
return
}
// Only the client handler owns copying; both handlers remain until it ends.
if ticket.Side == "client" {
n.mu.Lock()
agent := p.peers["agent"]
n.mu.Unlock()
n.copy(p.ctx, ws, agent)
p.cancel()
} else {
<-p.ctx.Done()
}
}
func (n *Node) copy(parent context.Context, a, b *websocket.Conn) {
ctx, cancel := context.WithCancel(parent)
defer cancel()
var wg sync.WaitGroup
copyOne := func(dst, src *websocket.Conn) {
defer wg.Done()
defer cancel()
for {
typ, data, err := src.Read(ctx)
if err != nil || typ != websocket.MessageBinary {
return
}
deadline, stop := context.WithTimeout(ctx, 30*time.Second)
err = dst.Write(deadline, typ, data)
stop()
if err != nil {
return
}
n.bytes.Add(int64(len(data)))
}
}
wg.Add(2)
go copyOne(a, b)
go copyOne(b, a)
wg.Wait()
}
func (n *Node) Close() {
n.mu.Lock()
defer n.mu.Unlock()
for _, p := range n.pairs {
p.cancel()
}
}
+144
View File
@@ -0,0 +1,144 @@
package relay
import (
"bytes"
"context"
"encoding/json"
"github.com/coder/websocket"
"github.com/pion/stun/v3"
"net"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
)
const secret = "test-cluster-secret-at-least-thirty-two-bytes"
func TestTicketScope(t *testing.T) {
now := time.Now()
good := Ticket{"s", "l", "n", "client", now.Add(time.Minute).Unix()}
encoded := Sign(secret, good)
if _, err := Verify(secret, encoded, "n", now); err != nil {
t.Fatal(err)
}
cases := []struct {
token, node string
when time.Time
}{{encoded, "other", now}, {encoded, "n", now.Add(2 * time.Minute)}, {encoded + "x", "n", now}, {Sign(secret, Ticket{"s", "l", "n", "admin", good.Expires}), "n", now}, {Sign(secret, Ticket{"s", "l", "n", "agent", now.Add(time.Hour).Unix()}), "n", now}}
for _, c := range cases {
if _, err := Verify(secret, c.token, c.node, c.when); err == nil {
t.Fatal("accepted invalid ticket")
}
}
}
func TestNodePairReplayAndRevocation(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
n := NewNode(ctx, "n", secret, 2)
defer n.Close()
s := httptest.NewServer(n.Handler())
defer s.Close()
ticket := func(side string) string {
return Sign(secret, Ticket{"s", "l", "n", side, time.Now().Add(time.Minute).Unix()})
}
dial := func(token string) (*websocket.Conn, *http.Response, error) {
return websocket.Dial(ctx, strings.Replace(s.URL, "http:", "ws:", 1)+"/v2/tunnel", &websocket.DialOptions{HTTPHeader: http.Header{"Authorization": []string{"Bearer " + token}}})
}
if c, r, e := dial(secret); e == nil {
c.CloseNow()
t.Fatal("accepted master secret as ticket")
} else if r.StatusCode != 401 {
t.Fatal(r.StatusCode)
}
a, _, err := dial(ticket("agent"))
if err != nil {
t.Fatal(err)
}
defer a.CloseNow()
c, _, err := dial(ticket("client"))
if err != nil {
t.Fatal(err)
}
defer c.CloseNow()
if other, r, e := dial(ticket("client")); e == nil {
other.CloseNow()
t.Fatal("replay accepted")
} else if r.StatusCode != 409 {
t.Fatal(r.StatusCode)
}
if err = c.Write(ctx, websocket.MessageBinary, []byte("adb")); err != nil {
t.Fatal(err)
}
kind, data, err := a.Read(ctx)
if err != nil || kind != websocket.MessageBinary || string(data) != "adb" {
t.Fatal(kind, string(data), err)
}
req, _ := http.NewRequest("POST", s.URL+"/internal/revoke", bytes.NewBufferString(`{"lease":"l"}`))
req.Header.Set("Authorization", "Bearer "+secret)
response, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
response.Body.Close()
if response.StatusCode != 204 {
t.Fatal(response.StatusCode)
}
if _, _, err := c.Read(ctx); err == nil {
t.Fatal("revocation did not close stream")
}
if other, r, e := dial(ticket("agent")); e == nil {
other.CloseNow()
t.Fatal("revoked ticket accepted")
} else if r.StatusCode != 409 {
t.Fatal(r.StatusCode)
}
}
func TestFailedUpgradeReleasesCapacity(t *testing.T) {
n := NewNode(context.Background(), "n", secret, 1)
defer n.Close()
req := httptest.NewRequest("GET", "/v2/tunnel", nil)
req.Header.Set("Authorization", "Bearer "+Sign(secret, Ticket{"s", "l", "n", "agent", time.Now().Add(time.Minute).Unix()}))
n.Handler().ServeHTTP(httptest.NewRecorder(), req)
recorder := httptest.NewRecorder()
n.Handler().ServeHTTP(recorder, httptest.NewRequest("GET", "/healthz", nil))
var value struct{ Sessions int }
json.Unmarshal(recorder.Body.Bytes(), &value)
if value.Sessions != 0 {
t.Fatal(value)
}
}
func TestSTUNBinding(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)})
if err != nil {
t.Fatal(err)
}
go ServeSTUN(ctx, conn)
client, err := net.DialUDP("udp", nil, conn.LocalAddr().(*net.UDPAddr))
if err != nil {
t.Fatal(err)
}
defer client.Close()
client.SetDeadline(time.Now().Add(time.Second))
request := stun.MustBuild(stun.TransactionID, stun.BindingRequest)
client.Write(request.Raw)
buffer := make([]byte, 1500)
size, err := client.Read(buffer)
if err != nil {
t.Fatal(err)
}
response := &stun.Message{Raw: buffer[:size]}
if err = response.Decode(); err != nil {
t.Fatal(err)
}
var mapped stun.XORMappedAddress
if err = mapped.GetFrom(response); err != nil {
t.Fatal(err)
}
if mapped.Port != client.LocalAddr().(*net.UDPAddr).Port || !mapped.IP.Equal(net.IPv4(127, 0, 0, 1)) || response.TransactionID != request.TransactionID {
t.Fatal(mapped)
}
}
+42
View File
@@ -0,0 +1,42 @@
package relay
import (
"context"
"github.com/pion/stun/v3"
"net"
"time"
)
// ServeSTUN handles binding only; no TURN allocations or arbitrary destinations.
// A fixed global budget bounds work and reflection traffic without a per-IP map.
func ServeSTUN(ctx context.Context, conn *net.UDPConn) error {
go func() { <-ctx.Done(); conn.Close() }()
buffer := make([]byte, 1500)
budget, reset := 100, time.Now()
for {
size, address, err := conn.ReadFromUDP(buffer)
if err != nil {
if ctx.Err() != nil {
return nil
}
return err
}
if time.Since(reset) >= time.Second {
budget = 100
reset = time.Now()
}
if budget == 0 || size < 20 || size > 1200 {
continue
}
budget--
message := &stun.Message{Raw: buffer[:size]}
if message.Decode() != nil || message.Type != stun.BindingRequest {
continue
}
response, err := stun.Build(stun.NewTransactionIDSetter(message.TransactionID), stun.BindingSuccess,
&stun.XORMappedAddress{IP: address.IP, Port: address.Port})
if err == nil {
conn.WriteToUDP(response.Raw, address)
}
}
}
+52
View File
@@ -0,0 +1,52 @@
package relay
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"errors"
"strings"
"time"
)
type Ticket struct {
Session string `json:"session"`
Lease string `json:"lease"`
Node string `json:"node"`
Side string `json:"side"`
Expires int64 `json:"expires"`
}
func Sign(secret string, ticket Ticket) string {
payload, _ := json.Marshal(ticket)
encoded := base64.RawURLEncoding.EncodeToString(payload)
mac := hmac.New(sha256.New, []byte(secret))
mac.Write([]byte(encoded))
return encoded + "." + base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
}
func Verify(secret, encoded, node string, now time.Time) (Ticket, error) {
var ticket Ticket
parts := strings.Split(encoded, ".")
if len(parts) != 2 {
return ticket, errors.New("invalid ticket")
}
signature, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
return ticket, errors.New("invalid ticket")
}
mac := hmac.New(sha256.New, []byte(secret))
mac.Write([]byte(parts[0]))
if !hmac.Equal(signature, mac.Sum(nil)) {
return ticket, errors.New("invalid ticket")
}
payload, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil || json.Unmarshal(payload, &ticket) != nil {
return ticket, errors.New("invalid ticket")
}
if ticket.Node != node || ticket.Expires <= now.Unix() || ticket.Expires > now.Add(2*time.Minute).Unix() || ticket.Session == "" || ticket.Lease == "" || (ticket.Side != "client" && ticket.Side != "agent") {
return ticket, errors.New("expired or invalid ticket")
}
return ticket, nil
}
+41 -11
View File
@@ -25,6 +25,7 @@ import (
type agent struct {
id string
ws *websocket.Conn
v2 bool
}
type lease struct {
id string
@@ -32,13 +33,15 @@ type lease struct {
ws *websocket.Conn
}
type session struct {
id string
agent *agent
lease *lease
ready chan *websocket.Conn
ctx context.Context
cancel context.CancelFunc
claimed bool
id string
agent *agent
lease *lease
ready chan *websocket.Conn
ctx context.Context
cancel context.CancelFunc
claimed bool
v2 bool
signalKey string
}
type broker struct {
mu sync.Mutex
@@ -47,6 +50,7 @@ type broker struct {
sessions map[string]*session
agentToken, clientToken string
ctx context.Context
cluster *cluster
}
func newBroker(ctx context.Context, agentToken, clientToken string) *broker {
@@ -132,7 +136,7 @@ func (b *broker) agentEndpoint(w http.ResponseWriter, r *http.Request) {
return
}
// Reserve before upgrading, so duplicate agents never replace an existing one.
a := &agent{id: id}
a := &agent{id: id, v2: r.URL.Query().Get("v") == "2"}
b.mu.Lock()
if b.agents[id] != nil {
b.mu.Unlock()
@@ -169,7 +173,11 @@ func (b *broker) agentEndpoint(w http.ResponseWriter, r *http.Request) {
b.mu.Lock()
a.ws = ws
b.mu.Unlock()
if err := writeJSON(b.ctx, ws, map[string]string{"type": "registered", "device": id}); err != nil {
registered := map[string]any{"type": "registered", "device": id}
if a.v2 {
registered["protocol"] = 2
}
if err := writeJSON(b.ctx, ws, registered); err != nil {
return
}
log.Printf("agent online: %s", id)
@@ -220,6 +228,7 @@ func (b *broker) leaseEndpoint(w http.ResponseWriter, r *http.Request) {
}
}
b.mu.Unlock()
b.cluster.revoke(l.id)
}()
ws, err := accept(w, r)
if err != nil {
@@ -233,7 +242,15 @@ func (b *broker) leaseEndpoint(w http.ResponseWriter, r *http.Request) {
}
l.ws = ws
b.mu.Unlock()
if err := writeJSON(b.ctx, ws, map[string]string{"type": "leased", "lease": l.id}); err != nil {
protocol := 1
if b.cluster != nil && a.v2 && r.URL.Query().Get("v") == "2" {
protocol = 2
}
leased := map[string]any{"type": "leased", "lease": l.id}
if r.URL.Query().Get("v") == "2" {
leased["protocol"] = protocol
}
if err := writeJSON(b.ctx, ws, leased); err != nil {
return
}
hold(b.ctx, ws)
@@ -287,7 +304,7 @@ func (b *broker) dataEndpoint(w http.ResponseWriter, r *http.Request) {
ticket, id := r.URL.Query().Get("session"), r.URL.Query().Get("device")
b.mu.Lock()
s := b.sessions[ticket]
if s == nil || s.agent.id != id || b.agents[id] != s.agent || s.claimed || s.ctx.Err() != nil {
if s == nil || s.v2 || s.agent.id != id || b.agents[id] != s.agent || s.claimed || s.ctx.Err() != nil {
b.mu.Unlock()
http.Error(w, "invalid or expired session", 404)
return
@@ -342,12 +359,17 @@ func (b *broker) handler() http.Handler {
mux.HandleFunc("GET /v1/devices", b.auth(b.clientToken, b.devicesEndpoint))
mux.HandleFunc("GET /v1/lease", b.auth(b.clientToken, b.leaseEndpoint))
mux.HandleFunc("GET /v1/connect", b.auth(b.clientToken, b.connectEndpoint))
mux.HandleFunc("GET /v2/nodes", b.auth(b.clientToken, b.nodesEndpoint))
mux.HandleFunc("GET /v2/connect", b.auth(b.clientToken, b.clusterConnectEndpoint))
mux.HandleFunc("GET /v2/signal", b.auth(b.agentToken, b.signalEndpoint))
return mux
}
func main() {
listen := flag.String("listen", "127.0.0.1:8080", "HTTP listen address (use a TLS reverse proxy for public access)")
cert := flag.String("tls-cert", "", "TLS certificate PEM path")
key := flag.String("tls-key", "", "TLS private key PEM path")
clusterFile := flag.String("cluster-config", "", "Cluster configuration JSON; empty preserves standalone v1 mode")
insecureNodes := flag.Bool("allow-insecure-nodes", false, "Allow ws relay URLs for isolated integration tests")
flag.Parse()
agentToken, clientToken := os.Getenv("ADS_AGENT_TOKEN"), os.Getenv("ADS_CLIENT_TOKEN")
if len(agentToken) < 32 || len(clientToken) < 32 || agentToken == clientToken {
@@ -359,6 +381,14 @@ func main() {
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
b := newBroker(ctx, agentToken, clientToken)
if *clusterFile != "" {
configured, err := loadCluster(*clusterFile, os.Getenv("ADS_RELAY_SECRET"), *insecureNodes)
if err != nil {
log.Fatal(err)
}
b.cluster = configured
go configured.monitor(ctx)
}
server := &http.Server{Addr: *listen, Handler: b.handler(), ReadHeaderTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 * 1024}
go func() {
<-ctx.Done()