Files

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")
}
}