You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/console/broker.go

184 lines
4.5 KiB
Go

package console
import (
"context"
"crypto/rand"
"encoding/base64"
"errors"
"fmt"
"io"
"net"
"sync"
"time"
"github.com/coder/websocket"
)
const (
defaultMaxFrame = 8 << 20
maxPendingTickets = 256
)
var (
ErrInvalidTicket = errors.New("console ticket is invalid, expired, or already used")
ErrTicketCapacity = errors.New("console ticket capacity is exhausted")
)
type Ticket struct {
Ticket string `json:"ticket"`
ExpiresAt time.Time `json:"expires_at"`
}
type entry struct {
address string
expiresAt time.Time
}
type Broker struct {
ttl time.Duration
now func() time.Time
dialer net.Dialer
mu sync.Mutex
tickets map[string]entry
maxFrame int64
}
func NewBroker(ttl time.Duration) (*Broker, error) {
if ttl <= 0 || ttl > 60*time.Second {
return nil, errors.New("console ticket TTL must be between 1 and 60 seconds")
}
return &Broker{
ttl: ttl, now: time.Now, dialer: net.Dialer{Timeout: 5 * time.Second},
tickets: make(map[string]entry), maxFrame: defaultMaxFrame,
}, nil
}
func (b *Broker) SetClockForTesting(now func() time.Time) {
b.mu.Lock()
defer b.mu.Unlock()
b.now = now
}
func (b *Broker) Issue(address string) (Ticket, error) {
if err := validateLoopbackTarget(address); err != nil {
return Ticket{}, err
}
random := make([]byte, 32)
if _, err := rand.Read(random); err != nil {
return Ticket{}, fmt.Errorf("generate console ticket: %w", err)
}
value := base64.RawURLEncoding.EncodeToString(random)
b.mu.Lock()
defer b.mu.Unlock()
now := b.now().UTC()
b.purgeLocked(now)
if len(b.tickets) >= maxPendingTickets {
return Ticket{}, ErrTicketCapacity
}
expires := now.Add(b.ttl)
b.tickets[value] = entry{address: address, expiresAt: expires}
return Ticket{
Ticket: value, ExpiresAt: expires,
}, nil
}
// Open atomically consumes one short-lived ticket before dialing the local
// loopback VNC target. A failed dial never makes the ticket reusable.
func (b *Broker) Open(ctx context.Context, ticket string) (net.Conn, error) {
address, ok := b.consume(ticket)
if !ok {
return nil, ErrInvalidTicket
}
backend, err := b.dialer.DialContext(ctx, "tcp", address)
if err != nil {
return nil, fmt.Errorf("dial local console: %w", err)
}
return backend, nil
}
// Relay copies only binary WebSocket messages between the authenticated
// reverse console channel and the local VNC TCP socket.
func (b *Broker) Relay(parent context.Context, conn *websocket.Conn, backend net.Conn) {
ctx, cancel := context.WithCancel(parent)
defer cancel()
errorsChannel := make(chan error, 2)
go func() { errorsChannel <- copyWebSocketToTCP(ctx, conn, backend) }()
go func() { errorsChannel <- copyTCPToWebSocket(ctx, conn, backend) }()
<-errorsChannel
cancel()
_ = backend.Close()
_ = conn.CloseNow()
select {
case <-errorsChannel:
case <-time.After(time.Second):
}
}
func copyWebSocketToTCP(ctx context.Context, conn *websocket.Conn, backend net.Conn) error {
for {
messageType, reader, err := conn.Reader(ctx)
if err != nil {
return err
}
if messageType != websocket.MessageBinary {
_ = conn.Close(websocket.StatusUnsupportedData, "binary frames required")
return errors.New("text console frame rejected")
}
if _, err := io.Copy(backend, reader); err != nil {
return err
}
}
}
func copyTCPToWebSocket(ctx context.Context, conn *websocket.Conn, backend net.Conn) error {
buffer := make([]byte, 32<<10)
for {
count, err := backend.Read(buffer)
if count > 0 {
if writeErr := conn.Write(ctx, websocket.MessageBinary, buffer[:count]); writeErr != nil {
return writeErr
}
}
if err != nil {
return err
}
}
}
func (b *Broker) consume(ticket string) (string, bool) {
b.mu.Lock()
defer b.mu.Unlock()
now := b.now().UTC()
b.purgeLocked(now)
value, ok := b.tickets[ticket]
if !ok || !value.expiresAt.After(now) {
return "", false
}
delete(b.tickets, ticket)
return value.address, true
}
func (b *Broker) purgeLocked(now time.Time) {
for key, value := range b.tickets {
if !value.expiresAt.After(now) {
delete(b.tickets, key)
}
}
}
func validateLoopbackTarget(address string) error {
host, port, err := net.SplitHostPort(address)
if err != nil {
return errors.New("console target must be a host:port pair")
}
ip := net.ParseIP(host)
if ip == nil || !ip.Equal(net.IPv4(127, 0, 0, 1)) {
return errors.New("console target must be 127.0.0.1")
}
parsedPort, err := net.LookupPort("tcp", port)
if err != nil || parsedPort < 1 || parsedPort > 65535 {
return errors.New("console target has an invalid port")
}
return nil
}