206 lines
7.3 KiB
Go
206 lines
7.3 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"golang.org/x/net/websocket"
|
|
"pageswiki/internal/geckorelay"
|
|
)
|
|
|
|
const geckoTestKey = "synthetic-server-relay-key-at-least-32-bytes"
|
|
|
|
func configureTestGecko(t *testing.T, s *Server, domain, origin string) {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "key")
|
|
if err := os.WriteFile(path, []byte(geckoTestKey), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("PAGESWIKI_GECKO_RELAY", origin)
|
|
t.Setenv("PAGESWIKI_GECKO_KEY_FILE", path)
|
|
if err := s.setSystemExtensionEnabled(domain, "viewer.gecko", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestFeedGeckoAuthorizationAndHeaders(t *testing.T) {
|
|
s, token, domain, actor, _ := feedFixture(t)
|
|
if s.systemExtensionEnabled(domain, "viewer.gecko") {
|
|
t.Fatal("experimental relay enabled by default")
|
|
}
|
|
for _, raw := range []string{"bad json", `{"organizer.feeds":true}`} {
|
|
if err := s.store.SetConfigInDomain(domain, systemExtensionStateKey, raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s.systemExtensionEnabled(domain, "viewer.gecko") {
|
|
t.Fatal("invalid/absent config enabled relay")
|
|
}
|
|
}
|
|
var requests atomic.Int64
|
|
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
requests.Add(1)
|
|
g, err := geckorelay.Verify(geckoTestKey, r.Header.Get(geckorelay.GrantHeader), time.Now())
|
|
if err != nil || g.Subject != domain+":"+actor {
|
|
t.Error("missing bound grant")
|
|
}
|
|
for _, h := range []string{"Cookie", "Authorization", "X-Forwarded-For", "Forwarded", "Referer"} {
|
|
if r.Header.Get(h) != "" {
|
|
t.Error("credential/header leaked", h)
|
|
}
|
|
}
|
|
if r.URL.Path != "/assets/v0.0.1/gecko.js" && r.URL.Path != "/distribution/v0.0.1/manifest.json" {
|
|
t.Error("path", r.URL.Path)
|
|
}
|
|
w.Header().Set("Set-Cookie", "forbidden=1")
|
|
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
|
|
io.WriteString(w, "export const fixture=true;")
|
|
}))
|
|
defer upstream.Close()
|
|
configureTestGecko(t, s, domain, upstream.URL)
|
|
r := httptest.NewRequest("GET", "http://localhost"+geckoAPI+"assets/v0.0.1/gecko.js", nil)
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
r.Header.Set("Cookie", "private=secret")
|
|
r.Header.Set("X-Forwarded-For", "secret")
|
|
w := httptest.NewRecorder()
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
if w.Code != 200 || requests.Load() != 1 || w.Header().Get("Set-Cookie") != "" {
|
|
t.Fatal(w.Code, w.Body)
|
|
}
|
|
if len(w.Header().Values("Cache-Control")) != 1 || strings.Contains(w.Header().Get("Cache-Control"), "no-store") {
|
|
t.Fatal("asset cache disabled", w.Header())
|
|
}
|
|
for _, tc := range []struct {
|
|
path, method string
|
|
code int
|
|
}{{"", "GET", 200}, {"wisp/", "GET", 403}, {"assets/v0.0.1/gecko.js?target=https://example.org", "GET", 400}, {"unknown", "GET", 404}, {"assets/v0.0.1/gecko.js", "POST", 400}} {
|
|
w = feedRequestTest(s, token, tc.method, "browser/"+tc.path, nil)
|
|
if w.Code != tc.code {
|
|
t.Fatalf("%s %s: %d %s", tc.method, tc.path, w.Code, w.Body)
|
|
}
|
|
if tc.path == "" && w.Header().Get("Cross-Origin-Embedder-Policy") != "require-corp" {
|
|
t.Fatal("not isolated")
|
|
}
|
|
}
|
|
if w = feedRequestTest(s, "", "GET", "browser/assets/v0.0.1/gecko.js", nil); w.Code == 200 {
|
|
t.Fatal("anonymous")
|
|
}
|
|
for _, origin := range []string{"https://evil.example", "null", "http://localhost.evil.example"} {
|
|
r := httptest.NewRequest("GET", "http://localhost"+geckoAPI+"wisp/", nil)
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
r.Header.Set("Origin", origin)
|
|
r.Header.Set("Upgrade", "websocket")
|
|
w := httptest.NewRecorder()
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
if w.Code != 403 {
|
|
t.Fatal("cross-site websocket", origin, w.Code)
|
|
}
|
|
}
|
|
prefs, err := s.store.TaskPreferences(context.Background(), domain, actor)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
prefs.RSSLinkMode = "gecko"
|
|
if _, err = s.store.SaveTaskPreferences(context.Background(), domain, actor, prefs, time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
page := func() *httptest.ResponseRecorder {
|
|
r := httptest.NewRequest("GET", "http://localhost/v/feeds", nil)
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
w := httptest.NewRecorder()
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
return w
|
|
}
|
|
w = page()
|
|
if w.Code != 200 || w.Header().Get("Cross-Origin-Opener-Policy") != "same-origin" || !strings.Contains(w.Body.String(), `data-link-mode="gecko"`) {
|
|
t.Fatal("isolated page", w.Code)
|
|
}
|
|
if err = s.setSystemExtensionEnabled(domain, "viewer.gecko", false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = page()
|
|
if w.Header().Get("Cross-Origin-Opener-Policy") != "" || !strings.Contains(w.Body.String(), `data-link-mode="tab"`) {
|
|
t.Fatal("disabled fallback")
|
|
}
|
|
if w = feedRequestTest(s, token, "GET", "browser/", nil); w.Code != 404 {
|
|
t.Fatal("disabled shell", w.Code)
|
|
}
|
|
if err = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if w = feedRequestTest(s, token, "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code != 200 {
|
|
t.Fatal("sources lost after disabling extensions", w.Code)
|
|
}
|
|
if w = feedRequestTest(s, "", "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code == 200 {
|
|
t.Fatal("anonymous source download")
|
|
}
|
|
if err = s.setSystemExtensionEnabled(domain, "organizer.feeds", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = s.setSystemExtensionEnabled(domain, "viewer.gecko", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.store.DB.Exec(`UPDATE principals SET state='readonly' WHERE uuid=?`, actor); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if w = feedRequestTest(s, token, "GET", "browser/", nil); w.Code != 404 {
|
|
t.Fatal("readonly browser", w.Code)
|
|
}
|
|
if w = feedRequestTest(s, token, "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code != 200 {
|
|
t.Fatal("readonly recipient lost source access", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestFeedGeckoWebsocketRevocation(t *testing.T) {
|
|
for _, disable := range []bool{false, true} {
|
|
t.Run(map[bool]string{false: "logout", true: "disable"}[disable], func(t *testing.T) {
|
|
s, token, domain, _, _ := feedFixture(t)
|
|
relay, err := geckorelay.New(geckoTestKey, t.TempDir())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
upstream := httptest.NewServer(relay)
|
|
defer upstream.Close()
|
|
configureTestGecko(t, s, domain, upstream.URL)
|
|
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
r.Host = "localhost"
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
}))
|
|
defer web.Close()
|
|
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(web.URL, "http")+geckoAPI+"wisp/", "http://localhost")
|
|
cfg.Header.Set("Authorization", "Bearer "+token)
|
|
conn, err := websocket.DialConfig(cfg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer conn.Close()
|
|
conn.SetDeadline(time.Now().Add(12 * time.Second))
|
|
var frame []byte
|
|
if err = websocket.Message.Receive(conn, &frame); err != nil || len(frame) != 9 || frame[0] != 3 || binary.LittleEndian.Uint32(frame[1:]) != 0 {
|
|
t.Fatal(frame, err)
|
|
}
|
|
if disable {
|
|
err = s.setSystemExtensionEnabled(domain, "viewer.gecko", false)
|
|
} else {
|
|
err = s.store.RevokeAuthSession(token)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
start := time.Now()
|
|
err = websocket.Message.Receive(conn, &frame)
|
|
if err == nil || time.Since(start) > 10*time.Second {
|
|
t.Fatal("session not promptly closed", err)
|
|
}
|
|
})
|
|
}
|
|
}
|