Implement authenticated public relay and Rust device daemons
This commit is contained in:
1 parent
f96c1aa109
commit
e1c152a657
29 files changed
+3244
-39
No files matched your search
+394
@@ -0,0 +1,394 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strings"
|
||||
"sync"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/coder/websocket"
|
||||
)
|
||||
|
||||
type agent struct {
|
||||
id string
|
||||
ws *websocket.Conn
|
||||
}
|
||||
type lease struct {
|
||||
id string
|
||||
device string
|
||||
ws *websocket.Conn
|
||||
}
|
||||
type session struct {
|
||||
id string
|
||||
agent *agent
|
||||
lease *lease
|
||||
ready chan *websocket.Conn
|
||||
ctx context.Context
|
||||
cancel context.CancelFunc
|
||||
claimed bool
|
||||
}
|
||||
type broker struct {
|
||||
mu sync.Mutex
|
||||
agents map[string]*agent
|
||||
leases map[string]*lease // indexed by device, one owner per device
|
||||
sessions map[string]*session
|
||||
agentToken, clientToken string
|
||||
ctx context.Context
|
||||
}
|
||||
|
||||
func newBroker(ctx context.Context, agentToken, clientToken string) *broker {
|
||||
return &broker{agents: make(map[string]*agent), leases: make(map[string]*lease),
|
||||
sessions: make(map[string]*session), agentToken: agentToken, clientToken: clientToken, ctx: ctx}
|
||||
}
|
||||
func newID() string {
|
||||
var data [24]byte
|
||||
if _, err := rand.Read(data[:]); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return hex.EncodeToString(data[:])
|
||||
}
|
||||
func validID(id string) bool {
|
||||
if len(id) < 1 || len(id) > 128 {
|
||||
return false
|
||||
}
|
||||
for _, c := range id {
|
||||
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("-_.", c)) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func (b *broker) auth(token string, handler http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if subtle.ConstantTimeCompare([]byte(r.Header.Get("Authorization")), []byte("Bearer "+token)) != 1 {
|
||||
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
handler(w, r)
|
||||
}
|
||||
}
|
||||
func accept(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
|
||||
conn, err := websocket.Accept(w, r, nil)
|
||||
if err == nil {
|
||||
conn.SetReadLimit(128 * 1024)
|
||||
}
|
||||
return conn, err
|
||||
}
|
||||
func writeJSON(ctx context.Context, ws *websocket.Conn, value any) error {
|
||||
data, err := json.Marshal(value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
||||
defer cancel()
|
||||
return ws.Write(ctx, websocket.MessageText, data)
|
||||
}
|
||||
|
||||
// A reader must be running while Ping waits for a pong.
|
||||
func hold(ctx context.Context, ws *websocket.Conn) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
go func() {
|
||||
ticker := time.NewTicker(20 * time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
pingCtx, stop := context.WithTimeout(ctx, 10*time.Second)
|
||||
err := ws.Ping(pingCtx)
|
||||
stop()
|
||||
if err != nil {
|
||||
cancel()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
for {
|
||||
if _, _, err := ws.Read(ctx); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
func (b *broker) agentEndpoint(w http.ResponseWriter, r *http.Request) {
|
||||
id := r.URL.Query().Get("device")
|
||||
if !validID(id) {
|
||||
http.Error(w, "invalid device ID", 400)
|
||||
return
|
||||
}
|
||||
// Reserve before upgrading, so duplicate agents never replace an existing one.
|
||||
a := &agent{id: id}
|
||||
b.mu.Lock()
|
||||
if b.agents[id] != nil {
|
||||
b.mu.Unlock()
|
||||
http.Error(w, "device already registered", 409)
|
||||
return
|
||||
}
|
||||
b.agents[id] = a
|
||||
b.mu.Unlock()
|
||||
defer func() {
|
||||
b.mu.Lock()
|
||||
if b.agents[id] == a {
|
||||
delete(b.agents, id)
|
||||
}
|
||||
for _, s := range b.sessions {
|
||||
if s.agent == a {
|
||||
s.cancel()
|
||||
}
|
||||
}
|
||||
l := b.leases[id]
|
||||
var leaseConn *websocket.Conn
|
||||
if l != nil {
|
||||
leaseConn = l.ws
|
||||
}
|
||||
b.mu.Unlock()
|
||||
if leaseConn != nil {
|
||||
leaseConn.CloseNow()
|
||||
}
|
||||
}()
|
||||
ws, err := accept(w, r)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer ws.CloseNow()
|
||||
b.mu.Lock()
|
||||
a.ws = ws
|
||||
b.mu.Unlock()
|
||||
if err := writeJSON(b.ctx, ws, map[string]string{"type": "registered", "device": id}); err != nil {
|
||||
return
|
||||
}
|
||||
log.Printf("agent online: %s", id)
|
||||
hold(b.ctx, ws)
|
||||
log.Printf("agent offline: %s", id)
|
||||
}
|
||||
func (b *broker) devicesEndpoint(w http.ResponseWriter, r *http.Request) {
|
||||
type device struct {
|
||||
ID string `json:"id"`
|
||||
Busy bool `json:"busy"`
|
||||
}
|
||||
devices := []device{}
|
||||
b.mu.Lock()
|
||||
for id, a := range b.agents {
|
||||
if a.ws != nil {
|
||||
devices = append(devices, device{id, b.leases[id] != nil})
|
||||
}
|
||||
}
|
||||
b.mu.Unlock()
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(devices)
|
||||
}
|
||||
func (b *broker) leaseEndpoint(w http.ResponseWriter, r *http.Request) {
|
||||
id := r.URL.Query().Get("device")
|
||||
b.mu.Lock()
|
||||
a := b.agents[id]
|
||||
if a == nil || a.ws == nil {
|
||||
b.mu.Unlock()
|
||||
http.Error(w, "device offline", 404)
|
||||
return
|
||||
}
|
||||
if b.leases[id] != nil {
|
||||
b.mu.Unlock()
|
||||
http.Error(w, "device busy", 409)
|
||||
return
|
||||
}
|
||||
l := &lease{id: newID(), device: id}
|
||||
b.leases[id] = l
|
||||
b.mu.Unlock()
|
||||
defer func() {
|
||||
b.mu.Lock()
|
||||
if b.leases[id] == l {
|
||||
delete(b.leases, id)
|
||||
}
|
||||
for _, s := range b.sessions {
|
||||
if s.lease == l {
|
||||
s.cancel()
|
||||
}
|
||||
}
|
||||
b.mu.Unlock()
|
||||
}()
|
||||
ws, err := accept(w, r)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer ws.CloseNow()
|
||||
b.mu.Lock()
|
||||
if b.agents[id] != a {
|
||||
b.mu.Unlock()
|
||||
return
|
||||
}
|
||||
l.ws = ws
|
||||
b.mu.Unlock()
|
||||
if err := writeJSON(b.ctx, ws, map[string]string{"type": "leased", "lease": l.id}); err != nil {
|
||||
return
|
||||
}
|
||||
hold(b.ctx, ws)
|
||||
}
|
||||
func (b *broker) connectEndpoint(w http.ResponseWriter, r *http.Request) {
|
||||
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.ws == nil || l == nil || l.ws == nil || l.id != leaseID {
|
||||
b.mu.Unlock()
|
||||
http.Error(w, "no active lease", 409)
|
||||
return
|
||||
}
|
||||
// Bound pending and active streams for each device.
|
||||
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}
|
||||
b.sessions[s.id] = s
|
||||
b.mu.Unlock()
|
||||
defer func() { s.cancel(); b.mu.Lock(); delete(b.sessions, s.id); b.mu.Unlock() }()
|
||||
client, err := accept(w, r)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer client.CloseNow()
|
||||
if err := writeJSON(ctx, a.ws, map[string]string{"type": "open", "session": s.id}); err != nil {
|
||||
return
|
||||
}
|
||||
timer := time.NewTimer(15 * time.Second)
|
||||
defer timer.Stop()
|
||||
select {
|
||||
case upstream := <-s.ready:
|
||||
defer upstream.CloseNow()
|
||||
bridgeWebSockets(ctx, client, upstream)
|
||||
case <-timer.C:
|
||||
client.Close(websocket.StatusTryAgainLater, "device connection timed out")
|
||||
case <-ctx.Done():
|
||||
}
|
||||
}
|
||||
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 {
|
||||
b.mu.Unlock()
|
||||
http.Error(w, "invalid or expired session", 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 bridgeWebSockets(ctx context.Context, left, right *websocket.Conn) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
copyMessages := func(dst, src *websocket.Conn) {
|
||||
defer cancel()
|
||||
for {
|
||||
typ, data, err := src.Read(ctx)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if typ != websocket.MessageBinary {
|
||||
return
|
||||
}
|
||||
writeCtx, stop := context.WithTimeout(ctx, 30*time.Second)
|
||||
err = dst.Write(writeCtx, typ, data)
|
||||
stop()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(2)
|
||||
go func() { defer wg.Done(); copyMessages(left, right) }()
|
||||
go func() { defer wg.Done(); copyMessages(right, left) }()
|
||||
wg.Wait()
|
||||
}
|
||||
func (b *broker) handler() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "ok\n") })
|
||||
mux.HandleFunc("GET /v1/agent", b.auth(b.agentToken, b.agentEndpoint))
|
||||
mux.HandleFunc("GET /v1/data", b.auth(b.agentToken, b.dataEndpoint))
|
||||
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))
|
||||
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")
|
||||
flag.Parse()
|
||||
agentToken, clientToken := os.Getenv("ADS_AGENT_TOKEN"), os.Getenv("ADS_CLIENT_TOKEN")
|
||||
if len(agentToken) < 32 || len(clientToken) < 32 || agentToken == clientToken {
|
||||
log.Fatal("set distinct ADS_AGENT_TOKEN and ADS_CLIENT_TOKEN, at least 32 characters each")
|
||||
}
|
||||
if (*cert == "") != (*key == "") {
|
||||
log.Fatal("provide both --tls-cert and --tls-key")
|
||||
}
|
||||
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
b := newBroker(ctx, agentToken, clientToken)
|
||||
server := &http.Server{Addr: *listen, Handler: b.handler(), ReadHeaderTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 * 1024}
|
||||
go func() {
|
||||
<-ctx.Done()
|
||||
b.mu.Lock()
|
||||
for _, a := range b.agents {
|
||||
if a.ws != nil {
|
||||
a.ws.CloseNow()
|
||||
}
|
||||
}
|
||||
for _, l := range b.leases {
|
||||
if l.ws != nil {
|
||||
l.ws.CloseNow()
|
||||
}
|
||||
}
|
||||
for _, s := range b.sessions {
|
||||
s.cancel()
|
||||
}
|
||||
b.mu.Unlock()
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
server.Shutdown(shutdownCtx)
|
||||
}()
|
||||
log.Printf("ADS relay listening on %s", *listen)
|
||||
var err error
|
||||
if *cert != "" {
|
||||
err = server.ListenAndServeTLS(*cert, *key)
|
||||
} else {
|
||||
err = server.ListenAndServe()
|
||||
}
|
||||
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
log.Fatal(fmt.Errorf("server: %w", err))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user