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