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.
184 lines
4.5 KiB
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
|
|
}
|