205 lines
6.3 KiB
Go
205 lines
6.3 KiB
Go
package transport
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"aeternalis/server/content"
|
|
"aeternalis/server/internal/game"
|
|
p "aeternalis/server/internal/protocol"
|
|
"aeternalis/server/internal/store"
|
|
"github.com/coder/websocket"
|
|
)
|
|
|
|
func TestHTTPAndSocketSecurity(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
db, err := store.Open(ctx, "file:"+filepath.ToSlash(filepath.Join(t.TempDir(), "http.db")))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
b, _ := content.Load()
|
|
w := game.New("test", 123, time.Now(), b)
|
|
lease, _, err := db.Acquire(ctx, w)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
svc := NewService(w, lease)
|
|
auth, _ := NewAuth(ctx, db, true, "http://127.0.0.1", "", "", "")
|
|
server := httptest.NewServer(NewHTTP(svc, auth, t.TempDir(), nil).Handler())
|
|
defer server.Close()
|
|
auth.base = server.URL
|
|
go svc.Run(ctx)
|
|
defer func() { cancel(); <-svc.done; _ = svc.Stop(context.Background()) }()
|
|
request := func(path, origin, body string, cookie *http.Cookie) *http.Response {
|
|
t.Helper()
|
|
req, _ := http.NewRequest(http.MethodPost, server.URL+path, strings.NewReader(body))
|
|
if origin != "" {
|
|
req.Header.Set("Origin", origin)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
if cookie != nil {
|
|
req.AddCookie(cookie)
|
|
}
|
|
response, err := server.Client().Do(req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return response
|
|
}
|
|
for _, origin := range []string{"", "https://evil.example", "null", server.URL + ".evil"} {
|
|
r := request("/auth/dev", origin, "{}", nil)
|
|
r.Body.Close()
|
|
if r.StatusCode != 403 {
|
|
t.Fatalf("accepted origin %q", origin)
|
|
}
|
|
}
|
|
r := request("/auth/dev", server.URL, "{}", nil)
|
|
cookies := r.Cookies()
|
|
r.Body.Close()
|
|
if len(cookies) != 1 || !cookies[0].HttpOnly {
|
|
t.Fatal("missing HttpOnly session")
|
|
}
|
|
cookie := cookies[0]
|
|
r = request("/api/join", server.URL, `{"name":"Traveler","passage":"","hp":999}`, cookie)
|
|
r.Body.Close()
|
|
if r.StatusCode != 400 {
|
|
t.Fatal("unknown join field accepted")
|
|
}
|
|
r = request("/api/join", server.URL, `{"name":"Traveler","passage":""}`, cookie)
|
|
raw, _ := io.ReadAll(r.Body)
|
|
r.Body.Close()
|
|
if r.StatusCode != 200 {
|
|
t.Fatalf("join %d %s", r.StatusCode, raw)
|
|
}
|
|
var character p.Character
|
|
if err = json.Unmarshal(raw, &character); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wsURL := "ws" + strings.TrimPrefix(server.URL, "http") + "/ws"
|
|
badCtx, stop := context.WithTimeout(ctx, time.Second)
|
|
_, response, err := websocket.Dial(badCtx, wsURL, &websocket.DialOptions{HTTPHeader: http.Header{"Origin": []string{"https://evil.example"}, "Cookie": []string{cookie.String()}}})
|
|
stop()
|
|
if err == nil || response.StatusCode != 403 {
|
|
t.Fatal("cross-origin websocket accepted")
|
|
}
|
|
socketCtx, stopSocket := context.WithTimeout(ctx, 5*time.Second)
|
|
defer stopSocket()
|
|
conn, _, err := websocket.Dial(socketCtx, wsURL, &websocket.DialOptions{HTTPHeader: http.Header{"Origin": []string{server.URL}, "Cookie": []string{cookie.String()}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer conn.CloseNow()
|
|
conn.SetReadLimit(2 << 20)
|
|
_, data, err := conn.Read(socketCtx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var s p.Snapshot
|
|
if err = json.Unmarshal(data, &s); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(s.Chunks) != 9 {
|
|
t.Fatal("missing chunk snapshot")
|
|
}
|
|
if bytes.Contains(data, []byte(`"account"`)) {
|
|
t.Fatal("account identity leaked")
|
|
}
|
|
// Public configuration and unauthenticated routes must never expose recipes.
|
|
for _, path := range []string{"/api/config", "/api/crafting", "/api/control/catalog"} {
|
|
response, e := server.Client().Get(server.URL + path)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
body, _ := io.ReadAll(response.Body)
|
|
response.Body.Close()
|
|
if bytes.Contains(body, []byte("recipe_spear")) || bytes.Contains(body, []byte(`"recipes"`)) {
|
|
t.Fatal("secret recipes exposed", path)
|
|
}
|
|
if path != "/api/config" && response.StatusCode == 200 {
|
|
t.Fatal("unauthenticated crafting/catalog access", path)
|
|
}
|
|
}
|
|
svc.mu.Lock()
|
|
c := svc.world.Characters[character.Entity.ID]
|
|
c.View.Inventory["herb"] = 10
|
|
svc.mu.Unlock()
|
|
craft := p.CraftRequest{ID: game.ID(), CharacterID: character.Entity.ID, Profession: "alchemist", Ingredients: map[string]int64{"herb": 2}}
|
|
body, _ := json.Marshal(craft)
|
|
for _, origin := range []string{"", "https://evil.example"} {
|
|
response := request("/api/craft", origin, string(body), cookie)
|
|
response.Body.Close()
|
|
if response.StatusCode != 403 {
|
|
t.Fatal("cross-origin crafting accepted")
|
|
}
|
|
}
|
|
for _, path := range []string{"/api/revive", "/api/revival/consent", "/api/item-action"} {
|
|
r := request(path, "https://evil.example", "{}", cookie)
|
|
r.Body.Close()
|
|
if r.StatusCode != 403 {
|
|
t.Fatal("cross-origin revival accepted", path)
|
|
}
|
|
r = request(path, server.URL, "{}", nil)
|
|
r.Body.Close()
|
|
if r.StatusCode != 401 {
|
|
t.Fatal("unauthenticated revival accepted", path)
|
|
}
|
|
}
|
|
response = request("/api/craft", server.URL, string(body), cookie)
|
|
var outcome p.CraftResult
|
|
if e := json.NewDecoder(response.Body).Decode(&outcome); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
response.Body.Close()
|
|
if response.StatusCode != 200 || !outcome.Valid || outcome.Recipe == nil {
|
|
t.Fatal("ingredient craft did not record valid recipe", outcome)
|
|
}
|
|
get, _ := http.NewRequest("GET", server.URL+"/api/crafting", nil)
|
|
get.AddCookie(cookie)
|
|
response, err = server.Client().Do(get)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var known struct {
|
|
Known []p.KnownRecipe `json:"known"`
|
|
}
|
|
if err = json.NewDecoder(response.Body).Decode(&known); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
response.Body.Close()
|
|
if len(known.Known) != 1 || known.Known[0].Recipe.ID != "recipe_bandage" {
|
|
t.Fatal("crafting returned undiscovered recipes")
|
|
}
|
|
intent := p.Intent{Op: "move", Seq: 1, X: 1}
|
|
payload, _ := json.Marshal(intent)
|
|
if err = conn.Write(socketCtx, websocket.MessageText, payload); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = conn.Write(socketCtx, websocket.MessageText, []byte(`{"op":"move","seq":2,"x":1,"z":0,"target":"","hp":999}`)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for {
|
|
_, _, err = conn.Read(socketCtx)
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
if err == nil {
|
|
t.Fatal("malformed intent was not disconnected")
|
|
}
|
|
}
|
|
func TestProductionAuthRequiresOIDC(t *testing.T) {
|
|
if _, err := NewAuth(context.Background(), nil, false, "http://insecure", "", "", ""); err == nil {
|
|
t.Fatal("insecure production auth accepted")
|
|
}
|
|
}
|