feat(feeds): add opt-in Gecko relay and folder shortcuts
Document engine redistribution requirements; exclude upstream engine assets and keep the viewer disabled by default.
This commit is contained in:
1 parent
b23e63d4c6
commit
5321d613b4
37 files changed
+2051
-29
No files matched your search
@@ -21,6 +21,7 @@ type Manifest struct {
|
||||
|
||||
func Catalog() []Manifest {
|
||||
return []Manifest{
|
||||
{ID: "viewer.gecko", APIVersion: 1, Version: "0.1.0", Kind: "viewer", Scope: "domain", NameKey: "feeds.gecko", DescriptionKey: "feeds.gecko_help", Capabilities: []string{"feeds.own.read"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: false, ResourceClass: "client-compute+relay-network"},
|
||||
{ID: "organizer.feeds", APIVersion: 1, Version: "0.1.0", Kind: "feeds", Scope: "domain", NameKey: "feeds.title", DescriptionKey: "feeds.help", Capabilities: []string{"feeds.own.read", "feeds.own.write"}, Events: []string{"feed.source.sync"}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "background+network+index"},
|
||||
{ID: "organizer.contacts", APIVersion: 1, Version: "0.2.0", Kind: "contacts", Scope: "domain", NameKey: "contacts.title", DescriptionKey: "contacts.help", Capabilities: []string{"contacts.own.read", "contacts.own.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
|
||||
{ID: "organizer.tasks", APIVersion: 1, Version: "0.14.0", Kind: "tasks", Scope: "domain", NameKey: "tasks.title", DescriptionKey: "tasks.help", Capabilities: []string{"tasks.own.read", "tasks.own.write"}, Events: []string{"organizer.task.changed", "organizer.project.changed", "task.digest.deliver"}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+background+index"},
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
PagesWiki Gecko relay
|
||||
|
||||
This image contains the PagesWiki TCP relay, not Firefox/Gecko, gecko.js,
|
||||
gecko.wasm.zst, Mozilla runtime assets or browser fonts.
|
||||
|
||||
Third-party code linked into the relay binary:
|
||||
- Go standard library and runtime, Copyright The Go Authors.
|
||||
BSD-3-Clause; full license: /licenses/Go.txt
|
||||
Source and release archives: https://go.dev/dl/
|
||||
- golang.org/x/net v0.35.0 (WebSocket transport), Copyright The Go Authors.
|
||||
BSD-3-Clause; full license: /licenses/golang-x-net.txt
|
||||
Source: https://go.googlesource.com/net/+/refs/tags/v0.35.0/
|
||||
|
||||
The licenses are copied from the exact toolchain/module used at build time.
|
||||
The scratch runtime image does not contain Alpine, BusyBox or apk.
|
||||
The PagesWiki integration source and engine redistribution assessment are in:
|
||||
https://git.anya.jp/anya/pages
|
||||
docs/operations/gecko-redistribution.md
|
||||
|
||||
Mounting and serving an independently obtained browser engine requires a
|
||||
separate assessment and delivery of its applicable notices and source offer.
|
||||
This relay notice is not a license grant for that engine.
|
||||
@@ -0,0 +1,137 @@
|
||||
// Package geckorelay provides a bounded TCP-only Wisp transport for Gecko.
|
||||
// It is not a public general-purpose proxy: the PagesWiki frontend authenticates
|
||||
// the user and signs each backend request, and every destination is checked here.
|
||||
package geckorelay
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/hmac"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net"
|
||||
"net/netip"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
const GrantHeader = "X-PagesWiki-Gecko-Grant"
|
||||
|
||||
type Grant struct {
|
||||
Subject string `json:"subject"`
|
||||
Nonce string `json:"nonce"`
|
||||
Expires int64 `json:"expires"`
|
||||
}
|
||||
|
||||
func Sign(key string, grant Grant) string {
|
||||
data, _ := json.Marshal(grant)
|
||||
body := base64.RawURLEncoding.EncodeToString(data)
|
||||
h := hmac.New(sha256.New, []byte(key))
|
||||
h.Write([]byte(body))
|
||||
return body + "." + base64.RawURLEncoding.EncodeToString(h.Sum(nil))
|
||||
}
|
||||
|
||||
func Verify(key, token string, now time.Time) (Grant, error) {
|
||||
var grant Grant
|
||||
parts := strings.Split(token, ".")
|
||||
if len(key) < 32 || len(token) > 2048 || len(parts) != 2 {
|
||||
return grant, errors.New("invalid grant")
|
||||
}
|
||||
sig, err := base64.RawURLEncoding.DecodeString(parts[1])
|
||||
if err != nil {
|
||||
return grant, errors.New("invalid grant")
|
||||
}
|
||||
h := hmac.New(sha256.New, []byte(key))
|
||||
h.Write([]byte(parts[0]))
|
||||
if !hmac.Equal(sig, h.Sum(nil)) {
|
||||
return grant, errors.New("invalid grant")
|
||||
}
|
||||
data, err := base64.RawURLEncoding.DecodeString(parts[0])
|
||||
if err != nil {
|
||||
return grant, errors.New("invalid grant")
|
||||
}
|
||||
if json.Unmarshal(data, &grant) != nil || grant.Subject == "" || len(grant.Subject) > 160 || len(grant.Nonce) < 16 || len(grant.Nonce) > 80 || grant.Expires <= now.Unix() || grant.Expires > now.Add(time.Minute).Unix() {
|
||||
return Grant{}, errors.New("invalid grant")
|
||||
}
|
||||
return grant, nil
|
||||
}
|
||||
|
||||
var denied = func() []netip.Prefix {
|
||||
var result []netip.Prefix
|
||||
for _, p := range []string{"0.0.0.0/8", "100.64.0.0/10", "192.0.0.0/24", "192.0.2.0/24", "192.88.99.0/24", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "240.0.0.0/4", "2001::/23", "2001:db8::/32", "2002::/16", "3fff::/20"} {
|
||||
result = append(result, netip.MustParsePrefix(p))
|
||||
}
|
||||
return result
|
||||
}()
|
||||
|
||||
func PublicIP(ip netip.Addr) bool {
|
||||
ip = ip.Unmap()
|
||||
if !ip.IsValid() || ip.Zone() != "" || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
|
||||
return false
|
||||
}
|
||||
// Only globally allocated IPv6 unicast; excludes NAT64, mapped/private and
|
||||
// future address classes rather than treating unknown ranges as public.
|
||||
if ip.Is6() && !netip.MustParsePrefix("2000::/3").Contains(ip) {
|
||||
return false
|
||||
}
|
||||
for _, p := range denied {
|
||||
if p.Contains(ip) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func ValidDestination(host string, port uint16) bool {
|
||||
if port != 80 && port != 443 {
|
||||
return false
|
||||
}
|
||||
if ip, err := netip.ParseAddr(host); err == nil {
|
||||
return PublicIP(ip)
|
||||
}
|
||||
host = strings.TrimSuffix(strings.ToLower(host), ".")
|
||||
if len(host) == 0 || len(host) > 253 || host == "localhost" || strings.HasSuffix(host, ".localhost") || !strings.Contains(host, ".") {
|
||||
return false
|
||||
}
|
||||
for _, label := range strings.Split(host, ".") {
|
||||
if len(label) == 0 || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' {
|
||||
return false
|
||||
}
|
||||
for _, c := range label {
|
||||
if !(c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '-') {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
type lookupFunc func(context.Context, string, string) ([]netip.Addr, error)
|
||||
type dialFunc func(context.Context, string, string) (net.Conn, error)
|
||||
|
||||
func dialPublic(ctx context.Context, host string, port uint16, lookup lookupFunc, dial dialFunc) (net.Conn, error) {
|
||||
if !ValidDestination(host, port) {
|
||||
return nil, errors.New("blocked destination")
|
||||
}
|
||||
ips, err := lookup(ctx, "ip", host)
|
||||
if err != nil || len(ips) == 0 || len(ips) > 16 {
|
||||
return nil, errors.New("destination lookup failed")
|
||||
}
|
||||
for _, ip := range ips {
|
||||
if !PublicIP(ip) {
|
||||
return nil, errors.New("blocked destination")
|
||||
}
|
||||
}
|
||||
for _, ip := range ips {
|
||||
conn, e := dial(ctx, "tcp", net.JoinHostPort(ip.Unmap().String(), strconv.Itoa(int(port))))
|
||||
if e == nil {
|
||||
return conn, nil
|
||||
}
|
||||
if ctx.Err() != nil {
|
||||
break
|
||||
}
|
||||
}
|
||||
return nil, errors.New("destination unavailable")
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package geckorelay
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
const AssetsPrefix = "/assets/v0.0.1/"
|
||||
|
||||
// Hashes of the two unmodified files in upstream v0.0.1. The release archive
|
||||
// itself is pinned in docs/operations/gecko-relay.md. Refuse mixed engine/glue.
|
||||
func VerifyAssets(dir string) error {
|
||||
for name, want := range map[string]string{
|
||||
"gecko.js": "e5aeebffd21106eccf23b1219316221add5e95085bc5a1bfb941117cfcd75ef7",
|
||||
"gecko.wasm.zst": "ebd6c75179152624d9644865e11792ed25cadc714d9e0985f412baf9c637a086",
|
||||
} {
|
||||
f, err := os.Open(filepath.Join(dir, name))
|
||||
if err != nil {
|
||||
return fmt.Errorf("required Gecko asset unavailable: %s", name)
|
||||
}
|
||||
h := sha256.New()
|
||||
_, err = io.Copy(h, io.LimitReader(f, 64<<20))
|
||||
f.Close()
|
||||
if err != nil || hex.EncodeToString(h.Sum(nil)) != want {
|
||||
return fmt.Errorf("Gecko asset checksum mismatch: %s", name)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,352 @@
|
||||
package geckorelay
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"golang.org/x/net/websocket"
|
||||
)
|
||||
|
||||
const (
|
||||
window = 8
|
||||
maxFrame = 256 << 10
|
||||
maxStreams = 16
|
||||
maxBytes = 256 << 20
|
||||
bytesPerSecond = 2 << 20
|
||||
)
|
||||
|
||||
type Relay struct {
|
||||
Key, Assets string
|
||||
mu sync.Mutex
|
||||
active map[string]bool
|
||||
used map[string]int64
|
||||
rx, tx, rejected atomic.Int64
|
||||
// Overridden only by package tests; deployment always resolves and pins public IPs.
|
||||
dial func(context.Context, string, uint16) (net.Conn, error)
|
||||
}
|
||||
|
||||
func New(key, assets string) (*Relay, error) {
|
||||
if len(key) < 32 {
|
||||
return nil, errors.New("relay key must contain at least 32 bytes")
|
||||
}
|
||||
r := &Relay{Key: key, Assets: assets, active: map[string]bool{}, used: map[string]int64{}}
|
||||
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
|
||||
defer cancel()
|
||||
return dialPublic(ctx, host, port, net.DefaultResolver.LookupNetIP, (&net.Dialer{Timeout: 2 * time.Second}).DialContext)
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
func (r *Relay) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
if req.URL.Path == "/health" && req.Method == "GET" {
|
||||
io.WriteString(w, "ok")
|
||||
return
|
||||
}
|
||||
grant, err := Verify(r.Key, req.Header.Get(GrantHeader), time.Now())
|
||||
if err != nil {
|
||||
http.Error(w, "forbidden", 403)
|
||||
return
|
||||
}
|
||||
if req.Method != "GET" || req.URL.RawQuery != "" {
|
||||
http.Error(w, "invalid request", 400)
|
||||
return
|
||||
}
|
||||
if req.URL.Path == "/status" {
|
||||
r.mu.Lock()
|
||||
active := len(r.active)
|
||||
r.mu.Unlock()
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]any{"active_sessions": active, "received_bytes": r.rx.Load(), "sent_bytes": r.tx.Load(), "rejected": r.rejected.Load(), "profile": "tcp-80-443", "max_sessions": 4, "max_streams": maxStreams, "bytes_per_second": bytesPerSecond, "max_session_bytes": maxBytes})
|
||||
return
|
||||
}
|
||||
if req.URL.Path == AssetsPrefix+"gecko.js" || req.URL.Path == AssetsPrefix+"gecko.wasm.zst" {
|
||||
w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
|
||||
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
|
||||
if strings.HasSuffix(req.URL.Path, ".js") {
|
||||
w.Header().Set("Content-Type", "text/javascript")
|
||||
} else {
|
||||
w.Header().Set("Content-Type", "application/octet-stream")
|
||||
}
|
||||
http.ServeFile(w, req, filepath.Join(r.Assets, filepath.Base(req.URL.Path)))
|
||||
return
|
||||
}
|
||||
if req.URL.Path != "/wisp/" {
|
||||
http.NotFound(w, req)
|
||||
return
|
||||
}
|
||||
r.mu.Lock()
|
||||
now := time.Now().Unix()
|
||||
for nonce, expires := range r.used {
|
||||
if expires <= now {
|
||||
delete(r.used, nonce)
|
||||
}
|
||||
}
|
||||
if r.active[grant.Subject] || len(r.active) >= 4 || r.used[grant.Nonce] > now || len(r.used) >= 256 {
|
||||
r.mu.Unlock()
|
||||
r.rejected.Add(1)
|
||||
http.Error(w, "session limit", 429)
|
||||
return
|
||||
}
|
||||
r.active[grant.Subject] = true
|
||||
r.used[grant.Nonce] = grant.Expires
|
||||
r.mu.Unlock()
|
||||
defer func() { r.mu.Lock(); delete(r.active, grant.Subject); r.mu.Unlock() }()
|
||||
wsServer := websocket.Server{Handshake: func(c *websocket.Config, req *http.Request) error {
|
||||
// Only the authenticated PagesWiki proxy can sign a grant. It validates
|
||||
// the browser Origin before forwarding, not the untrusted client header.
|
||||
if req.Header.Get("Origin") == "" {
|
||||
return errors.New("origin required")
|
||||
}
|
||||
return nil
|
||||
}, Handler: func(ws *websocket.Conn) { r.serve(ws) }}
|
||||
wsServer.ServeHTTP(w, req)
|
||||
}
|
||||
|
||||
type stream struct {
|
||||
data chan []byte
|
||||
done chan struct{}
|
||||
once sync.Once
|
||||
mu sync.Mutex
|
||||
conn net.Conn
|
||||
}
|
||||
|
||||
func (s *stream) close() {
|
||||
s.once.Do(func() {
|
||||
close(s.done)
|
||||
s.mu.Lock()
|
||||
if s.conn != nil {
|
||||
s.conn.Close()
|
||||
}
|
||||
s.mu.Unlock()
|
||||
})
|
||||
}
|
||||
func packet(kind byte, id uint32, data []byte) []byte {
|
||||
b := make([]byte, 5+len(data))
|
||||
b[0] = kind
|
||||
binary.LittleEndian.PutUint32(b[1:], id)
|
||||
copy(b[5:], data)
|
||||
return b
|
||||
}
|
||||
func credit() []byte { b := make([]byte, 4); binary.LittleEndian.PutUint32(b, window); return b }
|
||||
|
||||
func (r *Relay) serve(ws *websocket.Conn) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Minute)
|
||||
defer cancel()
|
||||
defer ws.Close()
|
||||
ws.MaxPayloadBytes = maxFrame + 5
|
||||
var mu, sendMu, budgetMu sync.Mutex
|
||||
streams := map[uint32]*stream{}
|
||||
var workers sync.WaitGroup
|
||||
var spent int64
|
||||
tokens := float64(bytesPerSecond)
|
||||
last := time.Now()
|
||||
account := func(n int) bool {
|
||||
budgetMu.Lock()
|
||||
defer budgetMu.Unlock()
|
||||
spent += int64(n)
|
||||
if spent > maxBytes {
|
||||
return false
|
||||
}
|
||||
now := time.Now()
|
||||
tokens += now.Sub(last).Seconds() * bytesPerSecond
|
||||
if tokens > bytesPerSecond {
|
||||
tokens = bytesPerSecond
|
||||
}
|
||||
last = now
|
||||
tokens -= float64(n)
|
||||
if tokens < 0 {
|
||||
timer := time.NewTimer(time.Duration(-tokens / bytesPerSecond * float64(time.Second)))
|
||||
defer timer.Stop()
|
||||
select {
|
||||
case <-timer.C:
|
||||
tokens = 0
|
||||
last = time.Now()
|
||||
case <-ctx.Done():
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
send := func(kind byte, id uint32, data []byte) error {
|
||||
sendMu.Lock()
|
||||
defer sendMu.Unlock()
|
||||
ws.SetWriteDeadline(time.Now().Add(10 * time.Second))
|
||||
return websocket.Message.Send(ws, packet(kind, id, data))
|
||||
}
|
||||
defer func() {
|
||||
cancel()
|
||||
mu.Lock()
|
||||
for _, s := range streams {
|
||||
s.close()
|
||||
}
|
||||
mu.Unlock()
|
||||
workers.Wait()
|
||||
}()
|
||||
go func() { <-ctx.Done(); ws.Close() }()
|
||||
if send(3, 0, credit()) != nil {
|
||||
return
|
||||
}
|
||||
connections := 0
|
||||
for {
|
||||
ws.SetReadDeadline(time.Now().Add(90 * time.Second))
|
||||
var b []byte
|
||||
if websocket.Message.Receive(ws, &b) != nil {
|
||||
return
|
||||
}
|
||||
if len(b) < 5 || !account(len(b)) {
|
||||
return
|
||||
}
|
||||
r.rx.Add(int64(len(b)))
|
||||
kind, id := b[0], binary.LittleEndian.Uint32(b[1:])
|
||||
if id == 0 {
|
||||
return
|
||||
}
|
||||
mu.Lock()
|
||||
s := streams[id]
|
||||
mu.Unlock()
|
||||
switch kind {
|
||||
case 1:
|
||||
connections++
|
||||
if s != nil || len(b) < 9 || len(b) > 261 || connections > 256 {
|
||||
return
|
||||
}
|
||||
port := binary.LittleEndian.Uint16(b[6:8])
|
||||
host := string(b[8:])
|
||||
if b[5] != 1 || !ValidDestination(host, port) {
|
||||
r.rejected.Add(1)
|
||||
if send(4, id, []byte{0x48}) != nil {
|
||||
return
|
||||
}
|
||||
continue
|
||||
}
|
||||
mu.Lock()
|
||||
full := len(streams) >= maxStreams
|
||||
mu.Unlock()
|
||||
if full {
|
||||
r.rejected.Add(1)
|
||||
if send(4, id, []byte{0x49}) != nil {
|
||||
return
|
||||
}
|
||||
continue
|
||||
}
|
||||
s = &stream{data: make(chan []byte, window), done: make(chan struct{})}
|
||||
mu.Lock()
|
||||
streams[id] = s
|
||||
mu.Unlock()
|
||||
workers.Add(1)
|
||||
go func(id uint32, s *stream, host string, port uint16) {
|
||||
defer workers.Done()
|
||||
defer func() { s.close(); mu.Lock(); delete(streams, id); mu.Unlock() }()
|
||||
dialCtx, stop := context.WithCancel(ctx)
|
||||
defer stop()
|
||||
go func() {
|
||||
select {
|
||||
case <-s.done:
|
||||
stop()
|
||||
case <-dialCtx.Done():
|
||||
}
|
||||
}()
|
||||
conn, e := r.dial(dialCtx, host, port)
|
||||
if e != nil {
|
||||
r.rejected.Add(1)
|
||||
send(4, id, []byte{0x48})
|
||||
return
|
||||
}
|
||||
s.mu.Lock()
|
||||
s.conn = conn
|
||||
s.mu.Unlock()
|
||||
select {
|
||||
case <-s.done:
|
||||
conn.Close()
|
||||
return
|
||||
default:
|
||||
}
|
||||
readerDone := make(chan struct{})
|
||||
defer func() { conn.Close(); <-readerDone }()
|
||||
go func() {
|
||||
defer close(readerDone)
|
||||
defer s.close()
|
||||
buffer := make([]byte, 64<<10)
|
||||
for {
|
||||
conn.SetReadDeadline(time.Now().Add(60 * time.Second))
|
||||
n, e := conn.Read(buffer)
|
||||
if n > 0 {
|
||||
if !account(n) {
|
||||
cancel()
|
||||
return
|
||||
}
|
||||
r.tx.Add(int64(n))
|
||||
if send(2, id, buffer[:n]) != nil {
|
||||
cancel()
|
||||
return
|
||||
}
|
||||
}
|
||||
if e != nil {
|
||||
send(4, id, []byte{2})
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
count := 0
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-s.done:
|
||||
return
|
||||
case data := <-s.data:
|
||||
conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
|
||||
if _, e = io.Copy(conn, bytes.NewReader(data)); e != nil {
|
||||
send(4, id, []byte{3})
|
||||
return
|
||||
}
|
||||
count++
|
||||
if count == window {
|
||||
count = 0
|
||||
if send(3, id, credit()) != nil {
|
||||
cancel()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}(id, s, host, port)
|
||||
case 2:
|
||||
if s == nil {
|
||||
continue
|
||||
}
|
||||
select {
|
||||
case <-s.done:
|
||||
case s.data <- b[5:]:
|
||||
default:
|
||||
r.rejected.Add(1)
|
||||
s.close()
|
||||
if send(4, id, []byte{0x49}) != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
case 4:
|
||||
if len(b) != 6 {
|
||||
return
|
||||
}
|
||||
if s != nil {
|
||||
s.close()
|
||||
}
|
||||
default:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,284 @@
|
||||
package geckorelay
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/netip"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"golang.org/x/net/websocket"
|
||||
)
|
||||
|
||||
const testKey = "synthetic-relay-key-at-least-32-bytes-long"
|
||||
|
||||
func TestAssetsPin(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
if VerifyAssets(dir) == nil {
|
||||
t.Fatal("missing assets accepted")
|
||||
}
|
||||
for _, name := range []string{"gecko.js", "gecko.wasm.zst"} {
|
||||
if err := os.WriteFile(filepath.Join(dir, name), []byte("untrusted"), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if VerifyAssets(dir) == nil {
|
||||
t.Fatal("unverified assets accepted")
|
||||
}
|
||||
if assets := os.Getenv("PAGESWIKI_GECKO_TEST_ASSETS"); assets != "" {
|
||||
if err := VerifyAssets(assets); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGrant(t *testing.T) {
|
||||
now := time.Now()
|
||||
g := Grant{"domain:actor", "0123456789abcdef", now.Add(30 * time.Second).Unix()}
|
||||
token := Sign(testKey, g)
|
||||
if got, e := Verify(testKey, token, now); e != nil || got != g {
|
||||
t.Fatal(got, e)
|
||||
}
|
||||
for _, bad := range []string{token + "x", "", strings.Repeat("x", 2049), Sign(testKey, Grant{g.Subject, g.Nonce, now.Add(2 * time.Minute).Unix()}), Sign(testKey, Grant{g.Subject, g.Nonce, now.Unix()})} {
|
||||
if _, e := Verify(testKey, bad, now); e == nil {
|
||||
t.Fatal("accepted invalid grant")
|
||||
}
|
||||
}
|
||||
if _, e := Verify("other-key-at-least-32-bytes-long!!", token, now); e == nil {
|
||||
t.Fatal("wrong key")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDestinations(t *testing.T) {
|
||||
for _, host := range []string{"127.0.0.1", "localhost", "host.localhost", "10.0.0.1", "169.254.169.254", "100.64.0.1", "192.0.2.2", "198.19.0.1", "::1", "::ffff:127.0.0.1", "64:ff9b::808:808", "2002:808:808::1", "2001:db8::1", "3fff::1", "fd00::1", "fe80::1%eth0", "bad/host", "example.org\x00.evil", "singlelabel"} {
|
||||
if ValidDestination(host, 443) {
|
||||
t.Fatalf("allowed %q", host)
|
||||
}
|
||||
}
|
||||
for _, host := range []string{"example.org", "EXAMPLE.org.", "8.8.8.8", "2606:4700:4700::1111"} {
|
||||
if !ValidDestination(host, 443) {
|
||||
t.Fatal("blocked", host)
|
||||
}
|
||||
}
|
||||
if ValidDestination("example.org", 22) {
|
||||
t.Fatal("port allowed")
|
||||
}
|
||||
called := false
|
||||
dial := func(_ context.Context, _, addr string) (net.Conn, error) {
|
||||
called = true
|
||||
if addr != "8.8.8.8:443" {
|
||||
t.Fatal("unvalidated DNS re-resolution", addr)
|
||||
}
|
||||
a, b := net.Pipe()
|
||||
b.Close()
|
||||
return a, nil
|
||||
}
|
||||
lookup := func(_ context.Context, _, _ string) ([]netip.Addr, error) {
|
||||
return []netip.Addr{netip.MustParseAddr("8.8.8.8"), netip.MustParseAddr("127.0.0.1")}, nil
|
||||
}
|
||||
if _, err := dialPublic(context.Background(), "example.org", 443, lookup, dial); err == nil || called {
|
||||
t.Fatal("mixed DNS allowed")
|
||||
}
|
||||
lookup = func(_ context.Context, _, _ string) ([]netip.Addr, error) {
|
||||
return []netip.Addr{netip.MustParseAddr("8.8.8.8")}, nil
|
||||
}
|
||||
c, err := dialPublic(context.Background(), "example.org", 443, lookup, dial)
|
||||
if err != nil || !called {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c.Close()
|
||||
}
|
||||
|
||||
func TestRelayFramesAndLimits(t *testing.T) {
|
||||
r, _ := New(testKey, t.TempDir())
|
||||
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
|
||||
a, b := net.Pipe()
|
||||
go func() { defer b.Close(); io.Copy(b, b) }()
|
||||
return a, nil
|
||||
}
|
||||
s := httptest.NewServer(r)
|
||||
defer s.Close()
|
||||
grant := Sign(testKey, Grant{"domain:actor", "nonce-first-connection", time.Now().Add(30 * time.Second).Unix()})
|
||||
dial := func(token string) (*websocket.Conn, error) {
|
||||
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(s.URL, "http")+"/wisp/", "https://pages.example")
|
||||
cfg.Header.Set(GrantHeader, token)
|
||||
return websocket.DialConfig(cfg)
|
||||
}
|
||||
if c, e := dial(""); e == nil {
|
||||
c.Close()
|
||||
t.Fatal("anonymous websocket")
|
||||
}
|
||||
c, err := dial(grant)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer c.Close()
|
||||
c.SetDeadline(time.Now().Add(5 * time.Second))
|
||||
receive := func() []byte {
|
||||
var p []byte
|
||||
if e := websocket.Message.Receive(c, &p); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
return p
|
||||
}
|
||||
p := receive()
|
||||
if p[0] != 3 || binary.LittleEndian.Uint32(p[1:]) != 0 || binary.LittleEndian.Uint32(p[5:]) != window {
|
||||
t.Fatal(p)
|
||||
}
|
||||
if second, e := dial(grant); e == nil {
|
||||
second.Close()
|
||||
t.Fatal("duplicate actor/replayed grant")
|
||||
}
|
||||
connect := func(id uint32, host string, port uint16, kind byte) {
|
||||
body := []byte{kind, byte(port), byte(port >> 8)}
|
||||
body = append(body, host...)
|
||||
if e := websocket.Message.Send(c, packet(1, id, body)); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
connect(1, "127.0.0.1", 80, 1)
|
||||
if p = receive(); p[0] != 4 || p[5] != 0x48 {
|
||||
t.Fatal(p)
|
||||
}
|
||||
connect(2, "example.org", 443, 2)
|
||||
if p = receive(); p[0] != 4 {
|
||||
t.Fatal("UDP accepted")
|
||||
}
|
||||
connect(3, "example.org", 443, 1)
|
||||
for n := 0; n < window; n++ {
|
||||
if e := websocket.Message.Send(c, packet(2, 3, []byte("hello"))); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
got := 0
|
||||
creditSeen := false
|
||||
for got < window*5 || !creditSeen {
|
||||
p = receive()
|
||||
switch p[0] {
|
||||
case 2:
|
||||
got += len(p) - 5
|
||||
case 3:
|
||||
creditSeen = true
|
||||
default:
|
||||
t.Fatal(p)
|
||||
}
|
||||
}
|
||||
// Wisp credits count DATA frames, including empty payloads.
|
||||
for n := 0; n < window; n++ {
|
||||
if e := websocket.Message.Send(c, packet(2, 3, nil)); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
if p = receive(); p[0] != 3 || binary.LittleEndian.Uint32(p[1:]) != 3 {
|
||||
t.Fatal("empty frame credit", p)
|
||||
}
|
||||
websocket.Message.Send(c, packet(4, 3, []byte{2}))
|
||||
websocket.Message.Send(c, packet(9, 4, nil))
|
||||
var b []byte
|
||||
if websocket.Message.Receive(c, &b) == nil && b[0] != 4 {
|
||||
t.Fatal("invalid packet accepted")
|
||||
}
|
||||
resp, e := http.Get(s.URL + "/status")
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != 403 {
|
||||
t.Fatal("unprotected metrics")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRelayStreamBoundAndCancellation(t *testing.T) {
|
||||
r, _ := New(testKey, t.TempDir())
|
||||
var dialing atomic.Int64
|
||||
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
|
||||
dialing.Add(1)
|
||||
defer dialing.Add(-1)
|
||||
<-ctx.Done()
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
server := httptest.NewServer(r)
|
||||
defer server.Close()
|
||||
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(server.URL, "http")+"/wisp/", "https://pages.example")
|
||||
cfg.Header.Set(GrantHeader, Sign(testKey, Grant{"domain:actor", "stream-bound-nonce", time.Now().Add(30 * time.Second).Unix()}))
|
||||
c, err := websocket.DialConfig(cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer c.Close()
|
||||
c.SetDeadline(time.Now().Add(5 * time.Second))
|
||||
var frame []byte
|
||||
if err = websocket.Message.Receive(c, &frame); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for id := 1; id <= maxStreams+1; id++ {
|
||||
if err = websocket.Message.Send(c, packet(1, uint32(id), append([]byte{1, 80, 0}, []byte("example.org")...))); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err = websocket.Message.Receive(c, &frame); err != nil || len(frame) != 6 || frame[0] != 4 || binary.LittleEndian.Uint32(frame[1:]) != maxStreams+1 || frame[5] != 0x49 {
|
||||
t.Fatal("stream cap", frame, err)
|
||||
}
|
||||
c.Close()
|
||||
for n := 0; n < 100; n++ {
|
||||
r.mu.Lock()
|
||||
active := len(r.active)
|
||||
r.mu.Unlock()
|
||||
if active == 0 && dialing.Load() == 0 {
|
||||
return
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
t.Fatal("closing session did not cancel pending dials")
|
||||
}
|
||||
|
||||
func TestRelaySessionBoundAndReplay(t *testing.T) {
|
||||
r, _ := New(testKey, t.TempDir())
|
||||
server := httptest.NewServer(r)
|
||||
defer server.Close()
|
||||
dial := func(subject, nonce string) (*websocket.Conn, error) {
|
||||
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(server.URL, "http")+"/wisp/", "https://pages.example")
|
||||
cfg.Header.Set(GrantHeader, Sign(testKey, Grant{subject, nonce, time.Now().Add(30 * time.Second).Unix()}))
|
||||
return websocket.DialConfig(cfg)
|
||||
}
|
||||
var conns []*websocket.Conn
|
||||
for _, subject := range []string{"one", "two", "three", "four"} {
|
||||
c, e := dial(subject, "unique-session-nonce-"+subject)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
conns = append(conns, c)
|
||||
defer c.Close()
|
||||
}
|
||||
if c, e := dial("five", "unique-session-nonce-five"); e == nil {
|
||||
c.Close()
|
||||
t.Fatal("global cap exceeded")
|
||||
}
|
||||
conns[0].Close()
|
||||
for n := 0; n < 100; n++ {
|
||||
r.mu.Lock()
|
||||
active := len(r.active)
|
||||
r.mu.Unlock()
|
||||
if active == 3 {
|
||||
break
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
if c, e := dial("one", "unique-session-nonce-one"); e == nil {
|
||||
c.Close()
|
||||
t.Fatal("replayed after close")
|
||||
}
|
||||
c, e := dial("five", "unique-session-nonce-retry")
|
||||
if e != nil {
|
||||
t.Fatal("slot not released", e)
|
||||
}
|
||||
c.Close()
|
||||
}
|
||||
@@ -10,16 +10,26 @@ import (
|
||||
const systemExtensionStateKey = "system_extension_states"
|
||||
|
||||
func (s *Server) systemExtensionEnabled(domainUUID, id string) bool {
|
||||
defaultEnabled := true
|
||||
for _, manifest := range systemext.Catalog() {
|
||||
if manifest.ID == id {
|
||||
defaultEnabled = manifest.Enabled
|
||||
break
|
||||
}
|
||||
}
|
||||
raw, err := s.store.GetConfigInDomain(domainUUID, systemExtensionStateKey)
|
||||
if err != nil || strings.TrimSpace(raw) == "" {
|
||||
return true
|
||||
return defaultEnabled
|
||||
}
|
||||
var states map[string]bool
|
||||
if json.Unmarshal([]byte(raw), &states) != nil {
|
||||
return true
|
||||
return defaultEnabled
|
||||
}
|
||||
enabled, ok := states[id]
|
||||
return !ok || enabled
|
||||
if !ok {
|
||||
return defaultEnabled
|
||||
}
|
||||
return enabled
|
||||
}
|
||||
|
||||
func (s *Server) setSystemExtensionEnabled(domainUUID, id string, enabled bool) error {
|
||||
|
||||
@@ -30,6 +30,10 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
|
||||
taskError(w, store.ErrAccessDenied)
|
||||
return
|
||||
}
|
||||
if strings.HasPrefix(r.URL.Path, geckoAPI) {
|
||||
s.handleFeedBrowser(w, r, domain, actor, active)
|
||||
return
|
||||
}
|
||||
if r.URL.Path == "/v/feeds" {
|
||||
if r.Method != "GET" && r.Method != "HEAD" {
|
||||
w.WriteHeader(405)
|
||||
@@ -50,6 +54,13 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
|
||||
prefix = preferences.WikiPrefix
|
||||
linkMode = preferences.RSSLinkMode
|
||||
}
|
||||
if linkMode == "gecko" {
|
||||
if active && s.geckoAvailable(domain) {
|
||||
geckoIsolation(w)
|
||||
} else {
|
||||
linkMode = "tab"
|
||||
}
|
||||
}
|
||||
s.renderWithContext(w, r, "feeds.gohtml", map[string]any{"Title": "RSS", "FeedWritable": active, "FeedWikiPrefix": prefix, "FeedLinkMode": linkMode, "FeedShareX": s.systemExtensionEnabled(domain, "sharing.x")})
|
||||
return
|
||||
}
|
||||
|
||||
@@ -21,6 +21,10 @@ func TestRSSLinkPreference(t *testing.T) {
|
||||
if err != nil || p.RSSLinkMode != "embedded" {
|
||||
t.Fatal(p.RSSLinkMode, err)
|
||||
}
|
||||
p.RSSLinkMode = "gecko"
|
||||
if w := taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
p.RSSLinkMode = "unsafe"
|
||||
if w := taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 422 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httputil"
|
||||
"net/url"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"pageswiki/internal/geckorelay"
|
||||
)
|
||||
|
||||
const geckoAPI = feedsAPI + "browser/"
|
||||
|
||||
type geckoProxy struct {
|
||||
origin *url.URL
|
||||
key string
|
||||
transport *http.Transport
|
||||
}
|
||||
|
||||
func (s *Server) geckoConfig() *geckoProxy {
|
||||
s.geckoOnce.Do(func() {
|
||||
u, err := url.Parse(os.Getenv("PAGESWIKI_GECKO_RELAY"))
|
||||
if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Path != "" && u.Path != "/") {
|
||||
return
|
||||
}
|
||||
key, err := os.ReadFile(os.Getenv("PAGESWIKI_GECKO_KEY_FILE"))
|
||||
if err != nil || len(strings.TrimSpace(string(key))) < 32 {
|
||||
return
|
||||
}
|
||||
s.gecko = &geckoProxy{origin: u, key: strings.TrimSpace(string(key)), transport: &http.Transport{Proxy: nil, DialContext: (&net.Dialer{Timeout: 5 * time.Second}).DialContext, ResponseHeaderTimeout: 10 * time.Second, TLSHandshakeTimeout: 5 * time.Second, IdleConnTimeout: 30 * time.Second, MaxIdleConnsPerHost: 4}}
|
||||
})
|
||||
return s.gecko
|
||||
}
|
||||
|
||||
func (s *Server) geckoAvailable(domain string) bool {
|
||||
return s.systemExtensionEnabled(domain, "viewer.gecko") && s.geckoConfig() != nil
|
||||
}
|
||||
|
||||
func geckoIsolation(w http.ResponseWriter) {
|
||||
w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
|
||||
w.Header().Set("Cross-Origin-Embedder-Policy", "require-corp")
|
||||
w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
|
||||
}
|
||||
|
||||
func (s *Server) handleFeedBrowser(w http.ResponseWriter, r *http.Request, domain, actor string, active bool) {
|
||||
if !active || !s.geckoAvailable(domain) {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
if r.Method != "GET" || r.URL.RawQuery != "" {
|
||||
http.Error(w, "invalid request", 400)
|
||||
return
|
||||
}
|
||||
path := strings.TrimPrefix(r.URL.Path, geckoAPI)
|
||||
switch path {
|
||||
case "":
|
||||
geckoIsolation(w)
|
||||
w.Header().Set("Content-Security-Policy", "default-src 'none'; script-src 'self' blob: 'wasm-unsafe-eval'; worker-src 'self' blob:; connect-src 'self' data:; style-src 'self'; img-src 'self' data:; frame-ancestors 'self'; base-uri 'none'; form-action 'none'")
|
||||
w.Header().Set("Referrer-Policy", "no-referrer")
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
io.WriteString(w, geckoShell)
|
||||
return
|
||||
case "assets/v0.0.1/gecko.js", "assets/v0.0.1/gecko.wasm.zst":
|
||||
case "wisp/":
|
||||
// WebSocket cookies alone are not CSRF protection.
|
||||
if r.Header.Get("Origin") != externalURL(r, "") || !strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
|
||||
http.Error(w, "forbidden", 403)
|
||||
return
|
||||
}
|
||||
default:
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
cfg := s.geckoConfig()
|
||||
ctx, cancel := context.WithCancel(r.Context())
|
||||
defer cancel()
|
||||
if path == "wisp/" {
|
||||
token := s.authTokenFromRequest(r)
|
||||
go func() {
|
||||
ticker := time.NewTicker(5 * time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
p, err := s.store.PrincipalForSession(domain, token)
|
||||
if err != nil || p.UUID != actor || p.State != "active" || !s.systemExtensionEnabled(domain, "organizer.feeds") || !s.geckoAvailable(domain) {
|
||||
cancel()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
proxy := &httputil.ReverseProxy{Transport: cfg.transport, Rewrite: func(p *httputil.ProxyRequest) {
|
||||
p.SetURL(cfg.origin)
|
||||
p.Out.URL.Path = "/" + path
|
||||
p.Out.URL.RawPath = ""
|
||||
// No ambient credentials, forwarding headers, target URL or user-supplied
|
||||
// grant crosses this boundary. The relay origin is operator-configured.
|
||||
keep := http.Header{}
|
||||
for _, h := range []string{"Upgrade", "Connection", "Sec-WebSocket-Key", "Sec-WebSocket-Version", "Origin", "Range", "If-None-Match", "If-Modified-Since"} {
|
||||
if value := p.Out.Header.Get(h); value != "" {
|
||||
keep.Set(h, value)
|
||||
}
|
||||
}
|
||||
keep.Set(geckorelay.GrantHeader, geckorelay.Sign(cfg.key, geckorelay.Grant{Subject: domain + ":" + actor, Nonce: randomURLToken(24), Expires: time.Now().Add(30 * time.Second).Unix()}))
|
||||
p.Out.Header = keep
|
||||
}, ModifyResponse: func(resp *http.Response) error {
|
||||
resp.Header.Del("Set-Cookie")
|
||||
resp.Header.Set("Cross-Origin-Resource-Policy", "same-origin")
|
||||
if resp.Header.Get("Cache-Control") == "" {
|
||||
resp.Header.Set("Cache-Control", "private, no-store")
|
||||
}
|
||||
return nil
|
||||
}, ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
|
||||
w.Header().Set("Cache-Control", "private, no-store")
|
||||
http.Error(w, "browser relay unavailable", http.StatusBadGateway)
|
||||
}}
|
||||
// ReverseProxy adds upstream headers rather than replacing existing values.
|
||||
// Do not accidentally append the RSS API's no-store to versioned assets.
|
||||
w.Header().Del("Cache-Control")
|
||||
proxy.ServeHTTP(w, r.WithContext(ctx))
|
||||
}
|
||||
|
||||
const geckoShell = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="stylesheet" href="/static/css/feed-gecko.css?v=1"><title>Gecko</title></head><body><p id="status" role="status"></p><canvas id="screen" tabindex="0" aria-label="Original article"></canvas><script type="module" src="/static/js/feed-gecko.js?v=1"></script></body></html>`
|
||||
|
||||
func init() {
|
||||
translations["en"]["feeds.gecko"] = "Gecko RSS browser (experimental)"
|
||||
translations["ja"]["feeds.gecko"] = "Gecko RSSブラウザ(実験的)"
|
||||
translations["en"]["feeds.gecko_help"] = "Requires a separately deployed authenticated relay. Public HTTP/HTTPS only; browsing uses the relay's IP address."
|
||||
translations["ja"]["feeds.gecko_help"] = "認証付き中継サービスの別途配置が必要です。公開HTTP/HTTPSのみ。閲覧先には中継サーバーのIPが使われます。"
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"golang.org/x/net/websocket"
|
||||
"pageswiki/internal/geckorelay"
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
// The real engine runs against a synthetic Wisp HTTP responder. This test never
|
||||
// dials an article server, production source, DNS name or external calendar.
|
||||
func TestFeedGeckoChromium(t *testing.T) {
|
||||
assets := os.Getenv("PAGESWIKI_GECKO_TEST_ASSETS")
|
||||
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" || assets == "" {
|
||||
t.Skip("opt-in real Gecko assets")
|
||||
}
|
||||
var connections atomic.Int64
|
||||
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, err := geckorelay.Verify(geckoTestKey, r.Header.Get(geckorelay.GrantHeader), time.Now()); err != nil {
|
||||
http.Error(w, "bad grant", 403)
|
||||
return
|
||||
}
|
||||
if strings.HasPrefix(r.URL.Path, "/assets/") {
|
||||
http.ServeFile(w, r, filepath.Join(assets, filepath.Base(r.URL.Path)))
|
||||
return
|
||||
}
|
||||
if r.URL.Path != "/wisp/" {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
websocket.Handler(func(ws *websocket.Conn) {
|
||||
connections.Add(1)
|
||||
defer connections.Add(-1)
|
||||
packet := func(kind byte, id uint32, data []byte) []byte {
|
||||
out := make([]byte, 5+len(data))
|
||||
out[0] = kind
|
||||
binary.LittleEndian.PutUint32(out[1:], id)
|
||||
copy(out[5:], data)
|
||||
return out
|
||||
}
|
||||
websocket.Message.Send(ws, packet(3, 0, []byte{8, 0, 0, 0}))
|
||||
requests := map[uint32]string{}
|
||||
for {
|
||||
var p []byte
|
||||
if websocket.Message.Receive(ws, &p) != nil || len(p) < 5 {
|
||||
return
|
||||
}
|
||||
id := binary.LittleEndian.Uint32(p[1:])
|
||||
switch p[0] {
|
||||
case 1:
|
||||
requests[id] = ""
|
||||
case 2:
|
||||
requests[id] += string(p[5:])
|
||||
if !strings.Contains(requests[id], "\r\n\r\n") {
|
||||
continue
|
||||
}
|
||||
body := `<!doctype html><body style="margin:0;background:rgb(255,0,0)"><a style="display:block;width:300px;height:100px;background:blue;color:white" href="http://fixture.invalid/next">Synthetic next page</a><h1>Private fixture</h1>`
|
||||
if strings.HasPrefix(requests[id], "GET /next ") {
|
||||
body = `<!doctype html><body style="margin:0;background:rgb(0,255,0)"><h1>Second synthetic page</h1>`
|
||||
}
|
||||
response := fmt.Sprintf("HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: %d\r\nConnection: close\r\n\r\n%s", len(body), body)
|
||||
websocket.Message.Send(ws, packet(2, id, []byte(response)))
|
||||
websocket.Message.Send(ws, packet(4, id, []byte{2}))
|
||||
delete(requests, id)
|
||||
case 4:
|
||||
delete(requests, id)
|
||||
}
|
||||
}
|
||||
}).ServeHTTP(w, r)
|
||||
}))
|
||||
defer backend.Close()
|
||||
s, token, domain, actor, source := feedFixture(t)
|
||||
configureTestGecko(t, s, domain, backend.URL)
|
||||
p, e := s.store.TaskPreferences(context.Background(), domain, actor)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
p.RSSLinkMode = "gecko"
|
||||
if _, e = s.store.SaveTaskPreferences(context.Background(), domain, actor, p, time.Now()); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
claim, e := s.store.ClaimFeed(context.Background(), source)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if e = s.store.CompleteFeed(context.Background(), claim, []store.FeedItem{{ID: "synthetic", Title: "Gecko synthetic fixture", URL: "http://fixture.invalid/first", Body: "No external network access."}}, "", "", "", false); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
handler := s.handler()
|
||||
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Header.Get("Origin") == "http://"+r.Host {
|
||||
r.Header.Set("Origin", "http://localhost")
|
||||
}
|
||||
r.Host = "localhost"
|
||||
r.Header.Set("Authorization", "Bearer "+token)
|
||||
handler.ServeHTTP(w, r)
|
||||
}))
|
||||
defer web.Close()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 150*time.Second)
|
||||
defer cancel()
|
||||
out, e := exec.CommandContext(ctx, "node", "internal/server/testdata/feed-gecko-browser.mjs", web.URL+"/v/feeds", t.TempDir(), "/tmp/pageswiki-feed-gecko.png").CombinedOutput()
|
||||
if e != nil {
|
||||
t.Fatalf("browser: %v\n%s", e, out)
|
||||
}
|
||||
io.WriteString(os.Stdout, string(out))
|
||||
for i := 0; i < 30 && connections.Load() != 0; i++ {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
if connections.Load() != 0 {
|
||||
t.Fatal("viewer close left relay session alive")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
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" {
|
||||
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, "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)
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -19,7 +19,7 @@ func NormalizePath(
|
||||
// Hosted adapter assets use directory-relative module and worker URLs.
|
||||
// DAV collections also require the slash: removing it conflicts with
|
||||
// ServeMux's collection redirect and causes an infinite redirect loop.
|
||||
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") || strings.HasPrefix(p, "/_/api/v1/carddav/") {
|
||||
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") || strings.HasPrefix(p, "/_/api/v1/carddav/") || strings.HasPrefix(p, "/_/api/v1/extension/organizer.feeds/browser/") {
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -24,3 +24,18 @@ func TestNormalizePathDAVCollections(t *testing.T) {
|
||||
t.Fatal("Wiki canonicalization changed", w.Code, w.Header())
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizePathGeckoWebsocket(t *testing.T) {
|
||||
for _, path := range []string{"/_/api/v1/extension/organizer.feeds/browser/", "/_/api/v1/extension/organizer.feeds/browser/wisp/"} {
|
||||
w := httptest.NewRecorder()
|
||||
NormalizePath(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path != path {
|
||||
t.Fatal(r.URL.Path)
|
||||
}
|
||||
w.WriteHeader(401)
|
||||
})).ServeHTTP(w, httptest.NewRequest("GET", path, nil))
|
||||
if w.Code != 401 || w.Header().Get("Location") != "" {
|
||||
t.Fatal("redirected browser endpoint", w.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,8 @@ import (
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
geckoOnce sync.Once
|
||||
gecko *geckoProxy
|
||||
calendarOnce sync.Once
|
||||
calendarRepo *calendar.Repository
|
||||
calendarErr error
|
||||
@@ -351,7 +353,7 @@ func (s *Server) handler() http.Handler {
|
||||
domainHandler = h
|
||||
h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
background := r.URL.Query().Get("preview") == "1" ||
|
||||
strings.HasPrefix(r.URL.Path, "/v/preview-cache/")
|
||||
strings.HasPrefix(r.URL.Path, "/v/preview-cache/") || r.URL.Path == feedsAPI+"browser/wisp/"
|
||||
if !background {
|
||||
s.foregroundRequests.Add(1)
|
||||
defer s.foregroundRequests.Add(-1)
|
||||
|
||||
@@ -155,7 +155,7 @@ func (s *Server) handleTaskProductivity(w http.ResponseWriter, r *http.Request,
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
writeEventJSON(w, 200, map[string]any{"preferences": p, "defaults": defaultTask(p, time.Now().In(s.getLocation(domain))), "timezone": s.getTimezoneName(domain), "last_digest": last})
|
||||
writeEventJSON(w, 200, map[string]any{"preferences": p, "defaults": defaultTask(p, time.Now().In(s.getLocation(domain))), "timezone": s.getTimezoneName(domain), "last_digest": last, "gecko_available": s.geckoAvailable(domain)})
|
||||
return
|
||||
}
|
||||
if r.Method == "PUT" {
|
||||
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
import {spawn} from 'node:child_process';
|
||||
import {writeFile} from 'node:fs/promises';
|
||||
import {setTimeout as delay} from 'node:timers/promises';
|
||||
const [url,profile,screenshot]=process.argv.slice(2);
|
||||
const browser=spawn('chromium',['--headless','--no-sandbox','--disable-gpu','--disable-background-networking','--no-proxy-server','--remote-debugging-port=0',`--user-data-dir=${profile}`,'about:blank']);
|
||||
process.on('SIGTERM',()=>{browser.kill();process.exit(1);});
|
||||
let socket,logs=[];
|
||||
try {
|
||||
const endpoint=await new Promise((resolve,reject)=>{let text='';browser.stderr.on('data',c=>{text+=c;const match=text.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(match)resolve(match[1]);});browser.on('error',reject);browser.on('exit',code=>reject(Error('Browser exited '+code)));});
|
||||
socket=new WebSocket(endpoint);await new Promise((resolve,reject)=>{socket.onopen=resolve;socket.onerror=reject;});
|
||||
let id=0;const pending=new Map();
|
||||
socket.onmessage=e=>{const m=JSON.parse(e.data),p=pending.get(m.id);if(p){pending.delete(m.id);m.error?p.reject(Error(JSON.stringify(m.error))):p.resolve(m.result);}else if(['Runtime.exceptionThrown','Log.entryAdded','Runtime.consoleAPICalled'].includes(m.method))logs.push(JSON.stringify(m.params));};
|
||||
const send=(method,params={},sessionId)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});socket.send(JSON.stringify({id,method,params,sessionId}));});
|
||||
const {targetId}=await send('Target.createTarget',{url:'about:blank'}),{sessionId}=await send('Target.attachToTarget',{targetId,flatten:true});
|
||||
const call=(method,params)=>send(method,params,sessionId);
|
||||
const evaluate=async expression=>{const r=await call('Runtime.evaluate',{expression,returnByValue:true,awaitPromise:true});if(r.exceptionDetails)throw Error(JSON.stringify(r.exceptionDetails));return r.result.value;};
|
||||
const wait=async(expression,seconds=15)=>{for(let n=0;n<seconds*5;n++){if(await evaluate(expression))return;await delay(200);}if(screenshot){const {data}=await call('Page.captureScreenshot',{format:'png'});await writeFile(screenshot,Buffer.from(data,'base64'));}throw Error('Timeout: '+expression+'\n'+logs.slice(-30).join('\n'));};
|
||||
await call('Runtime.enable');await call('Log.enable');await call('Page.enable');
|
||||
// Only synthetic fixture diagnostics; production does not log article URLs.
|
||||
await call('Page.addScriptToEvaluateOnNewDocument',{source:`if(location.pathname.endsWith('/browser/'))import('/_/api/v1/extension/organizer.feeds/browser/assets/v0.0.1/gecko.js').then(({Gecko})=>{const init=Gecko.prototype.init;Gecko.prototype.init=function(){this.opts.printErr=console.warn;this.opts.print=console.log;return init.call(this);};});`});
|
||||
await call('Emulation.setDeviceMetricsOverride',{width:1280,height:850,deviceScaleFactor:1,mobile:false});await call('Page.navigate',{url});
|
||||
await wait(`document.querySelector('.feed-row')`);
|
||||
if(!await evaluate('crossOriginIsolated'))throw Error('Parent not isolated');
|
||||
await evaluate(`window.geckoReady=false;addEventListener('message',e=>{if(e.data?.type==='pageswiki-gecko'&&e.data.ready)geckoReady=true;});document.querySelector('.feed-row').click()`);
|
||||
await wait(`document.querySelector('.feed-original')`);await evaluate(`document.querySelector('.feed-original').click()`);
|
||||
await wait(`document.querySelector('.feed-external iframe')?.contentWindow.crossOriginIsolated`);
|
||||
await wait(`geckoReady || document.querySelector('.feed-external iframe')?.contentDocument?.querySelector('#status')?.textContent.includes('Viewer failed')`,100);
|
||||
if(!await evaluate('geckoReady'))throw Error('Gecko startup failed\n'+logs.slice(-8).join('\n'));
|
||||
const pixel=`(()=>{const c=document.querySelector('.feed-external iframe').contentDocument.querySelector('canvas');return Array.from(c.getContext('2d').getImageData(400,200,1,1).data)})()`;
|
||||
await wait(`${pixel}[0]===255 && ${pixel}[1]===0`);
|
||||
const rect=await evaluate(`(()=>{const r=document.querySelector('.feed-external iframe').getBoundingClientRect();return {x:r.x+100,y:r.y+50}})()`);
|
||||
await call('Input.dispatchMouseEvent',{type:'mousePressed',...rect,button:'left',buttons:1,clickCount:1});await call('Input.dispatchMouseEvent',{type:'mouseReleased',...rect,button:'left',buttons:0,clickCount:1});
|
||||
await wait(`${pixel}[0]===0 && ${pixel}[1]===255`);
|
||||
await wait(`document.querySelector('.feed-external a').href==='http://fixture.invalid/next'`);
|
||||
await evaluate(`document.querySelector('.feed-external button').click()`);
|
||||
await wait(`${pixel}[0]===255 && ${pixel}[1]===0`);
|
||||
if(screenshot){const {data}=await call('Page.captureScreenshot',{format:'png'});await writeFile(screenshot,Buffer.from(data,'base64'));}
|
||||
await evaluate(`document.querySelector('.feed-external').close()`);await wait(`!document.querySelector('.feed-external')`);
|
||||
console.log('Real Gecko: isolation, Wisp article render, click navigation, viewer-local back and teardown passed');
|
||||
}finally{socket?.close();browser.kill();await new Promise(resolve=>browser.once('exit',resolve));await delay(300);}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
import {memoryProfile} from '../../../static/js/feed-gecko-profile.mjs';
|
||||
import assert from 'node:assert/strict';
|
||||
const p=memoryProfile(10);
|
||||
await p.mkdir('cache');await p.writeFile('cache/a',new Uint8Array([1,2,3]));
|
||||
const copy=await p.readFile('cache/a');copy[0]=99;
|
||||
assert.equal((await p.readFile('cache/a'))[0],1);
|
||||
assert.deepEqual(await p.readdir(''),['cache/']);
|
||||
assert.deepEqual(await p.readdir('cache'),['a']);
|
||||
await p.rename('cache','new');assert.equal(await p.stat('cache'),null);
|
||||
assert.equal((await p.readFile('new/a')).length,3);
|
||||
await p.writeFile('b',new Uint8Array(5));await p.rename('new/a','b');
|
||||
await p.writeFile('c',new Uint8Array(7));
|
||||
await assert.rejects(p.writeFile('d',new Uint8Array(1)));
|
||||
for(const path of ['../secret','/absolute','new/../x','a\\b','a\0b'])await assert.rejects(p.stat(path));
|
||||
await p.unlink('b');await p.writeFile('d',new Uint8Array(3));
|
||||
assert.equal(await memoryProfile().stat('d'),null);
|
||||
console.log('Ephemeral profile bounds, isolation and rename passed');
|
||||
Vendored
+47
-3
@@ -4,6 +4,9 @@
|
||||
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
|
||||
try{
|
||||
await new Promise(resolve=>{frame.onload=resolve;frame.src='/v/feeds';});const d=frame.contentDocument,w=frame.contentWindow;
|
||||
// Let fixture requests finish before destroying a viewport's browser context.
|
||||
const fetch=w.fetch.bind(w);let pendingRequests=0;
|
||||
w.fetch=async(...args)=>{pendingRequests++;try{const response=await fetch(...args);await response.clone().arrayBuffer();return response;}finally{pendingRequests--;}};
|
||||
for(const key of Object.keys(w.localStorage))if(key.startsWith('pageswiki.feed-folders.v1:'))w.localStorage.removeItem(key);
|
||||
await wait(()=>d.querySelectorAll('.feed-row').length===100);
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'Viewport overflow');
|
||||
@@ -35,6 +38,47 @@
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'OPML preview overflow');
|
||||
const freshButton=()=>[...d.querySelectorAll('.feed-source>button:first-child')].find(b=>b.textContent==='FreshRSS fixture');freshButton().click();await wait(()=>d.querySelectorAll('.feed-folder').length===4&&d.querySelectorAll('.feed-row').length===2);
|
||||
const folder=id=>[...d.querySelectorAll('.feed-folder')].find(n=>n.dataset.category===id),tech=()=>folder('user/alice/label/Tech');
|
||||
const folderKey=(key,target=d,extra={})=>target.dispatchEvent(new w.KeyboardEvent('keydown',{key,shiftKey:true,bubbles:true,cancelable:true,...extra}));
|
||||
const activeFolder=()=>d.querySelector('.feed-folder-name[aria-current="true"]');
|
||||
const folderNames=()=>[...d.querySelectorAll('.feed-folder-name')];
|
||||
assert(help.textContent.includes('Shift+j/k'),'Folder shortcuts missing from help');
|
||||
// All subscriptions has no folder: start at either end, including empty/uncategorized.
|
||||
folderKey('K');await wait(()=>activeFolder()===folderNames().at(-1)&&d.querySelectorAll('.feed-row').length===0);
|
||||
folderKey('J');await delay(80);assert(activeFolder()===folderNames().at(-1),'Folder navigation wrapped past end');
|
||||
folderKey('K');await wait(()=>activeFolder()===tech().querySelector('.feed-folder-name')&&d.querySelector('.feed-row')?.textContent.includes('Catalog first'));
|
||||
assert(tech().querySelector('.feed-folder-toggle').getAttribute('aria-expanded')==='false','Keyboard navigation expanded folder');
|
||||
folderKey('k');await wait(()=>activeFolder()===folderNames()[1]&&d.querySelector('.feed-row')?.textContent.includes('Catalog second'));
|
||||
folderKey('K');await wait(()=>activeFolder()===folderNames()[0]&&d.querySelectorAll('.feed-row').length===0);
|
||||
folderKey('K');await delay(80);assert(activeFolder()===folderNames()[0],'Folder navigation wrapped before start');
|
||||
const articleFilter=d.querySelector('#feed-toolbar select');articleFilter.value='starred';articleFilter.dispatchEvent(new w.Event('change'));await delay(80);
|
||||
folderKey('J');await wait(()=>activeFolder()===folderNames()[1]);await delay(80);assert(articleFilter.value==='starred'&&d.querySelectorAll('.feed-row').length===0,'Folder navigation lost starred filter');
|
||||
articleFilter.value='';articleFilter.dispatchEvent(new w.Event('change'));await wait(()=>d.querySelector('.feed-row')?.textContent.includes('Catalog second'));
|
||||
folderKey('K');await wait(()=>activeFolder()===folderNames()[0]&&d.querySelectorAll('.feed-row').length===0);
|
||||
const keep=activeFolder();for(const extra of [{ctrlKey:true},{metaKey:true},{altKey:true},{isComposing:true}])folderKey('J',d,extra);
|
||||
const catalogFind=d.querySelector('.feed-catalog input');folderKey('J',catalogFind);
|
||||
const editable=d.createElement('div');editable.setAttribute('contenteditable','');editable.innerHTML='<span>editing</span>';d.body.append(editable);folderKey('J',editable.firstChild);editable.remove();
|
||||
await delay(80);assert(activeFolder()===keep,'Modifier or editable input triggered folder shortcut');
|
||||
// Preserve article filters while moving from a selected subscription to the next folder.
|
||||
tech().querySelector('.feed-folder-toggle').click();await wait(()=>tech().querySelector('[data-feed="feed/1"]'));
|
||||
tech().querySelector('[data-feed="feed/1"]').click();await wait(()=>d.querySelector('.feed-row')?.textContent.includes('Catalog first'));
|
||||
const globalSearch=d.querySelector('#feed-toolbar input');globalSearch.value='Catalog';globalSearch.dispatchEvent(new w.Event('input',{bubbles:true}));await delay(220);
|
||||
folderKey('K');await wait(()=>activeFolder()===folderNames()[1]&&d.querySelector('.feed-row')?.textContent.includes('Catalog second'));
|
||||
assert(globalSearch.value==='Catalog'&&!d.querySelector('button[data-feed][aria-current="true"]'),'Folder navigation lost search or kept subscription filter');
|
||||
d.querySelector('.feed-row').click();await wait(()=>d.querySelector('#feed-reader .feed-body'));
|
||||
const selectedTitle=d.querySelector('#feed-reader h1').textContent;
|
||||
d.querySelector('#feed-reader .feed-actions button:last-child').click();await wait(()=>d.querySelector('.feed-capture[open]'));
|
||||
folderKey('J');await delay(80);assert(activeFolder()===folderNames()[1]&&d.querySelector('#feed-reader h1').textContent===selectedTitle,'Shortcut escaped capture modal');
|
||||
d.querySelector('.feed-capture').close();await wait(()=>!d.querySelector('.feed-capture'));
|
||||
folderKey('J');await wait(()=>activeFolder()===tech().querySelector('.feed-folder-name')&&d.querySelector('.feed-row')?.textContent.includes('Catalog first'));
|
||||
assert(!d.querySelector('.feed-layout').classList.contains('reading')&&!d.querySelector('#feed-reader .feed-body'),'Folder navigation left old article open');
|
||||
catalogFind.value='Other';catalogFind.dispatchEvent(new w.Event('input',{bubbles:true}));assert(!activeFolder(),'Catalog filter setup');
|
||||
folderKey('K');await wait(()=>activeFolder()===folderNames()[1]&&d.querySelector('.feed-row')?.textContent.includes('Catalog second'));
|
||||
assert(d.querySelector('.feed-catalog input').value==='','Folder navigation left selected folder hidden by catalog filter');
|
||||
globalSearch.value='';globalSearch.dispatchEvent(new w.Event('input',{bubbles:true}));await delay(220);
|
||||
// Rapid repeats must settle on the latest folder rather than an older request.
|
||||
folderKey('J');folderKey('J');folderKey('K');await wait(()=>activeFolder()===tech().querySelector('.feed-folder-name')&&d.querySelector('.feed-row')?.textContent.includes('Catalog first'));await delay(100);
|
||||
assert(d.querySelectorAll('.feed-row').length===1&&d.querySelector('.feed-row').textContent.includes('Catalog first'),'Stale folder request won');
|
||||
tech().querySelector('.feed-folder-toggle').click();await wait(()=>tech().querySelector('.feed-folder-toggle').getAttribute('aria-expanded')==='false');
|
||||
tech().querySelector('.feed-folder-name').click();await wait(()=>d.querySelectorAll('.feed-row').length===1&&d.querySelector('.feed-row').textContent.includes('Catalog first'));
|
||||
assert(tech().querySelector('.feed-folder-toggle').getAttribute('aria-expanded')==='false','Selecting folder expands it unexpectedly');tech().querySelector('.feed-folder-toggle').click();await wait(()=>tech().querySelector('button[data-feed="feed/1"]'));
|
||||
const empty=folder('user/-/label/Empty/Folder');assert(empty.querySelector('.feed-folder-name span').textContent==='Empty/Folder','Slash label split');empty.querySelector('.feed-folder-toggle').click();assert(!empty.querySelector('button[data-feed]'),'Empty folder fabricated a feed');empty.querySelector('.feed-folder-name').click();await wait(()=>d.querySelectorAll('.feed-row').length===0);
|
||||
@@ -62,9 +106,9 @@
|
||||
assert((await w.fetch('/fixture/check-feed-history',{method:'POST'})).status===204,'Recheck worker failed');d.getElementById('feed-history-reload').click();await wait(()=>!receipt(seed.missing)&&receipt(seed.orphan));
|
||||
const hs=d.getElementById('feed-history-state');hs.value='all';hs.dispatchEvent(new w.Event('change'));await wait(()=>receipt(seed.missing)?.querySelector('[data-state=confirmed]'));
|
||||
d.dispatchEvent(new w.KeyboardEvent('keydown',{key:'Escape',bubbles:true}));assert(!d.querySelector('.feed-layout').classList.contains('action-history'),'History escape');
|
||||
d.getElementById('feed-history').click();await wait(()=>receipt(seed.orphan));d.getElementById('feed-history-state').value='all';d.getElementById('feed-history-state').dispatchEvent(new w.Event('change'));await wait(()=>receipt(seed.missing)?.querySelector('[data-state=confirmed]'));
|
||||
const previousHistory=d.getElementById('feed-history-panel');d.getElementById('feed-history').click();await wait(()=>d.getElementById('feed-history-panel')!==previousHistory&&receipt(seed.orphan));d.getElementById('feed-history-state').value='all';d.getElementById('feed-history-state').dispatchEvent(new w.Event('change'));await wait(()=>receipt(seed.missing)?.querySelector('[data-state=confirmed]'));
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'History final overflow');
|
||||
const probe=document.createElement('iframe');probe.hidden=true;document.body.append(probe);await new Promise(resolve=>{probe.onload=resolve;probe.src='/v/feeds?source='+encodeURIComponent(source.uuid);});await wait(()=>probe.contentDocument.querySelector('.feed-folder[data-category="user/alice/label/Tech"] .feed-folder-toggle')?.getAttribute('aria-expanded')==='true');probe.remove();
|
||||
freshButton().click();await wait(()=>tech()?.querySelector('button[data-feed="feed/1"]'));if(w.innerWidth<=700){d.querySelector('#feed-toolbar button').click();await wait(()=>d.querySelector('.feed-layout').classList.contains('sources-open'));assert(w.getComputedStyle(d.getElementById('feed-sources')).display!=='none','Mobile folders hidden');}assert(d.documentElement.scrollWidth<=w.innerWidth,'Folder tree overflow');document.body.dataset.vimReady='1';
|
||||
const probe=document.createElement('iframe');probe.hidden=true;document.body.append(probe);await new Promise(resolve=>{probe.onload=resolve;probe.src='/v/feeds?source='+encodeURIComponent(source.uuid);});await wait(()=>probe.contentDocument.querySelector('.feed-folder[data-category="user/alice/label/Tech"] .feed-folder-toggle')?.getAttribute('aria-expanded')==='true'&&probe.contentDocument.querySelectorAll('.feed-row').length===2);probe.remove();
|
||||
const previousCatalog=d.querySelector('.feed-catalog');freshButton().click();await wait(()=>d.querySelector('.feed-catalog')!==previousCatalog&&tech()?.querySelector('button[data-feed="feed/1"]')&&d.querySelectorAll('.feed-row').length===2);if(w.innerWidth<=700){d.querySelector('#feed-toolbar button').click();await wait(()=>d.querySelector('.feed-layout').classList.contains('sources-open'));assert(w.getComputedStyle(d.getElementById('feed-sources')).display!=='none','Mobile folders hidden');}assert(d.documentElement.scrollWidth<=w.innerWidth,'Folder tree overflow');await wait(()=>pendingRequests===0);await delay(100);document.body.dataset.vimReady='1';
|
||||
}catch(e){const out=document.createElement('pre');out.id='error';out.textContent=e.stack;document.body.append(out);}
|
||||
})();
|
||||
@@ -127,7 +127,7 @@ func (s *Store) SaveTaskPreferences(ctx context.Context, domain, actor string, p
|
||||
if p.RSSLinkMode == "" {
|
||||
p.RSSLinkMode = "tab"
|
||||
}
|
||||
if p.RSSLinkMode != "tab" && p.RSSLinkMode != "embedded" {
|
||||
if p.RSSLinkMode != "tab" && p.RSSLinkMode != "embedded" && p.RSSLinkMode != "gecko" {
|
||||
return p, ErrTaskInvalid
|
||||
}
|
||||
// Older clients do not send this field. Preserve their default clock.
|
||||
|
||||
Reference in new issue
Block a user