145 lines
4.4 KiB
Go
145 lines
4.4 KiB
Go
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)
|
|
}
|
|
}
|