diff --git a/Dockerfile.gecko-relay b/Dockerfile.gecko-relay new file mode 100644 index 0000000..c493adf --- /dev/null +++ b/Dockerfile.gecko-relay @@ -0,0 +1,18 @@ +# The relay image contains no browser engine. Mount the independently verified +# fixed Gecko distribution read-only at /gecko (see docs/operations/gecko-relay.md). +FROM golang:1.25-alpine AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY internal/geckorelay ./internal/geckorelay +COPY cmd/gecko-relay ./cmd/gecko-relay +RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /gecko-relay ./cmd/gecko-relay + +FROM scratch +COPY --from=build /gecko-relay /usr/local/bin/gecko-relay +COPY --from=build /usr/local/go/LICENSE /licenses/Go.txt +COPY --from=build /go/pkg/mod/golang.org/x/net@v0.35.0/LICENSE /licenses/golang-x-net.txt +COPY internal/geckorelay/NOTICE.txt /licenses/NOTICE.txt +USER 10001:10001 +EXPOSE 3012 +ENTRYPOINT ["/usr/local/bin/gecko-relay"] diff --git a/cmd/gecko-relay/main.go b/cmd/gecko-relay/main.go new file mode 100644 index 0000000..200aeb6 --- /dev/null +++ b/cmd/gecko-relay/main.go @@ -0,0 +1,76 @@ +package main + +import ( + "crypto/rand" + "encoding/hex" + "flag" + "io" + "log" + "net" + "net/http" + "os" + "strings" + "time" + + "pageswiki/internal/geckorelay" +) + +func main() { + status := flag.Bool("status", false, "print bounded relay resource counters") + flag.Parse() + // File mount avoids placing the shared secret in image layers or process args. + key, err := os.ReadFile(os.Getenv("PAGESWIKI_GECKO_KEY_FILE")) + if err != nil { + log.Fatal("Gecko relay key file unavailable") + } + secret := strings.TrimSpace(string(key)) + addr := os.Getenv("PAGESWIKI_GECKO_LISTEN") + if addr == "" { + addr = ":3012" + } + if *status { + host, port, err := net.SplitHostPort(addr) + if err != nil { + log.Fatal("invalid listen address") + } + if host == "" || host == "0.0.0.0" { + host = "127.0.0.1" + } + if host == "::" { + host = "::1" + } + nonce := make([]byte, 24) + if _, err = rand.Read(nonce); err != nil { + log.Fatal("random source unavailable") + } + req, _ := http.NewRequest("GET", "http://"+net.JoinHostPort(host, port)+"/status", nil) + req.Header.Set(geckorelay.GrantHeader, geckorelay.Sign(secret, geckorelay.Grant{Subject: "operator:status", Nonce: hex.EncodeToString(nonce), Expires: time.Now().Add(30 * time.Second).Unix()})) + client := http.Client{Timeout: 5 * time.Second, Transport: &http.Transport{Proxy: nil}, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} + resp, err := client.Do(req) + if err != nil { + log.Fatal("relay status unavailable") + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + log.Fatal("relay status denied") + } + if _, err = io.Copy(os.Stdout, io.LimitReader(resp.Body, 4096)); err != nil { + log.Fatal("relay status read failed") + } + return + } + assets := os.Getenv("PAGESWIKI_GECKO_ASSETS") + if assets == "" { + assets = "/gecko" + } + if err := geckorelay.VerifyAssets(assets); err != nil { + log.Fatal(err) + } + relay, err := geckorelay.New(secret, assets) + if err != nil { + log.Fatal(err) + } + s := &http.Server{Addr: addr, Handler: relay, ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 << 10} + log.Printf("Gecko relay listening; authenticated TCP 80/443 only") + log.Fatal(s.ListenAndServe()) +} diff --git a/data/pageswiki-cli b/data/pageswiki-cli index 16dcf24..a2857e8 100755 --- a/data/pageswiki-cli +++ b/data/pageswiki-cli @@ -1398,13 +1398,13 @@ class PagesWikiCLI: if not args: for extension_id, enabled in sorted(states.items()): print(f"{extension_id}\t{'enabled' if enabled else 'disabled'}") - print("(extensions not listed here use the default: enabled)") + print("(unlisted extensions use their manifest default; viewer.gecko: disabled, others: enabled)") return extension_id = args[0].strip() if not re.fullmatch(r"[a-z][a-z0-9._-]{1,63}", extension_id): raise CLIError("invalid extension ID") if len(args) == 1: - print(f"{extension_id}\t{'enabled' if states.get(extension_id, True) else 'disabled'}") + print(f"{extension_id}\t{'enabled' if states.get(extension_id, extension_id != 'viewer.gecko') else 'disabled'}") return value = args[1].lower() if value not in {"on", "off"}: diff --git a/data/pageswiki_cli_test.py b/data/pageswiki_cli_test.py index 215e1c9..6385121 100644 --- a/data/pageswiki_cli_test.py +++ b/data/pageswiki_cli_test.py @@ -1,6 +1,10 @@ import importlib.util from pathlib import Path import unittest +import sqlite3 +import io +from contextlib import redirect_stdout +from types import SimpleNamespace SCRIPT = Path(__file__).with_name("pageswiki-cli") @@ -43,5 +47,23 @@ class ContentTypeDetectionTest(unittest.TestCase): self.assertEqual(content_type, "text/plain; charset=shift_jis") +class ExtensionDefaultTest(unittest.TestCase): + def test_gecko_is_opt_in(self) -> None: + db = sqlite3.connect(":memory:") + self.addCleanup(db.close) + db.execute("CREATE TABLE config(domain_uuid TEXT,key TEXT,value TEXT,updated_at INTEGER,UNIQUE(domain_uuid,key))") + # Exercise the CLI command without reading any deployment database. + owner = next(value for value in vars(pageswiki_cli).values() if isinstance(value, type) and hasattr(value, "command_extension")) + fixture = SimpleNamespace(db=db, domain_uuid="synthetic") + output = io.StringIO() + with redirect_stdout(output): + owner.command_extension(fixture, ["viewer.gecko"]) + owner.command_extension(fixture, ["viewer.gecko", "on"]) + owner.command_extension(fixture, ["viewer.gecko"]) + owner.command_extension(fixture, ["viewer.gecko", "off"]) + owner.command_extension(fixture, ["viewer.gecko"]) + self.assertEqual(output.getvalue().splitlines(), ["viewer.gecko\tdisabled", "viewer.gecko\ton", "viewer.gecko\tenabled", "viewer.gecko\toff", "viewer.gecko\tdisabled"]) + + if __name__ == "__main__": unittest.main() diff --git a/docker-compose.gecko.yml b/docker-compose.gecko.yml new file mode 100644 index 0000000..2fefde1 --- /dev/null +++ b/docker-compose.gecko.yml @@ -0,0 +1,47 @@ +# Optional development/pilot overlay, never selected by the production recipe. +# Requires host egress rules; an isolated bridge alone is not an egress firewall. +services: + app: + environment: + PAGESWIKI_GECKO_RELAY: http://gecko-relay:3012 + PAGESWIKI_GECKO_KEY_FILE: /run/secrets/gecko-key + volumes: + - ${PAGESWIKI_GECKO_KEY_PATH:?Set absolute relay key path}:/run/secrets/gecko-key:ro + networks: + default: {} + gecko-front: {} + gecko-relay: + build: + context: . + dockerfile: Dockerfile.gecko-relay + image: pageswiki-gecko-relay:dev + environment: + PAGESWIKI_GECKO_KEY_FILE: /run/secrets/gecko-key + volumes: + - ${PAGESWIKI_GECKO_KEY_PATH:?Set absolute relay key path}:/run/secrets/gecko-key:ro + - ${PAGESWIKI_GECKO_ASSETS_DIR:?Set verified Gecko dist directory}:/gecko:ro + networks: + gecko-front: {} + gecko-egress: {} + read_only: true + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + mem_limit: 256m + cpus: 0.5 + pids_limit: 64 + restart: unless-stopped + healthcheck: + test: [CMD, /usr/local/bin/gecko-relay, --status] + interval: 30s + timeout: 3s + retries: 3 +networks: + gecko-front: + internal: true + ipam: + config: + - subnet: ${PAGESWIKI_GECKO_FRONT_SUBNET:-172.24.0.0/27} + gecko-egress: + ipam: + config: + - subnet: ${PAGESWIKI_GECKO_EGRESS_SUBNET:-172.24.0.32/27} diff --git a/docs/design/ja/feeds.md b/docs/design/ja/feeds.md index e2e3d3f..55e2a30 100644 --- a/docs/design/ja/feeds.md +++ b/docs/design/ja/feeds.md @@ -50,7 +50,7 @@ newsboat/neomuttを参考に、デスクトップは左から購読元・一 tooltipに残します。タブ名は「RSS」、原文リンクはアイコンです。件数・保持上限・操作の説明は常設せず、 キー案内は`?`で表示します。設定と保存フォームは本文ペイン内に置き、モーダルを増やしません。 -`j/k`・上下矢印で移動、`Enter/l`で本文、`Esc/h`で一覧、`/`で件名・配信元検索、`n`で次の未読、 +`j/k`・上下矢印で記事移動、`Shift+j/k`で次/前のFreshRSSフォルダ、`Enter/l`で本文、`Esc/h`で一覧、`/`で件名・配信元検索、`n`で次の未読、 `m`で既読切替、`*`でstar、`r`で背景更新予約、`?`でキー案内です。フォーム入力・IME変換中は 一覧ショートカットを抑止します。FreshRSSでは書戻し許可時だけ`m`と`*`で操作を予約します。 @@ -151,6 +151,15 @@ source指定と組み合わせ、既存の未読・star・検索・keysetペー 絞り込み対象は最新200記事のcache内に限られ、購読を選んでも履歴全件を外部取得しません。 購読の追加・削除やカテゴリの編集はFreshRSS側で行います。 +`Shift+j`/`Shift+k`は、選択中のFreshRSS接続内のフォルダを表示順に選び直します。 +空フォルダと未分類も含め、先頭・末尾では停止します。「すべての購読」からは、下方向なら先頭、 +上方向なら末尾を選びます。購読元を選択中なら、その所属フォルダを起点とします。 +記事検索・未読/starフィルタ・フォルダ開閉状態は維持し、個別購読元の絞り込みは解除します。 +購読・フォルダの検索でツリーが隠れている場合は、そのナビゲータ検索だけを解除します。 +前の本文と本文リクエストは破棄して一覧へ戻し、連打では最後の選択だけを反映します。 +フォーム・編集可能領域・モーダル・IME入力中、およびCtrl/Alt/Commandとの併用では実行しません。 +source自体の切替、分類の移動・書換え、外部再取得、未読/既読変更は行いません。 + ショートカットヘルプは`?`で開閉し、`Esc`または閉じるボタンでも閉じます。 ヘルプだけを閉じる操作では閲覧中の記事や入力フォームを変更せず、エラー等のstatus表示も保持します。 @@ -171,6 +180,54 @@ iframeは`allow-scripts`だけのsandboxと`no-referrer`を使い、親画面へ 表示できないページやログイン・フォーム操作が必要な場合は、dialog内の別タブアイコンを使います。 表示可否をcross-origin DOMの読取で判定したり、失敗を装って自動で別タブへ遷移したりはしません。 +### Geckoと自前Wispによる原文閲覧 + +通信中継方式を採用する。実装は独立した実験的ビューアとして段階導入し、現行の`tab`/`embedded`を +自動置換しない。Geckoビューア・中継・個人設定の接続を実装した。`viewer.gecko`は既定無効で、 +管理者による有効化と中継の構成が揃った場合だけ選択できる。本番への配備は別途行う。 + +端末上の`gecko.js`で1ページを描画し、外部HTTP(S)通信だけを管理者が配置したWispサービスへ中継する。 +サーバー上でFirefoxを起動したり画面をストリーミングしたりはしない。Firefox全体の操作画面は含めず、 +既存の記事上dialogにcanvas、戻る・進む・再読込・閉じる・別タブの操作を置く。 +自前中継を必須とし、Puter等の公開中継への自動fallbackは設けない。 + +現行upstreamはGeckoのソケット通信をWispへ接続する。通常のWebページの`fetch`へ単純に置き換えて +任意のサイトを直接取得することは前提にしない。GeckoとWisp実装は検証したrevision・プロトコルで固定し、 +更新時にサイト互換性とセキュリティ修正を再評価する。 +[gecko.js v0.0.1](https://github.com/HeyPuter/firefox-wasm/releases/tag/v0.0.1)、 +[Wisp仕様](https://github.com/MercuryWorkshop/wisp-protocol/blob/main/protocol.md)。 + +中継はPagesWiki本体とは別コンテナ・別ネットワーク境界とする。外部から無認証で利用できる公開proxyにしない。 +既存の認証・Domain・本人に束縛した短命セッションを発行し、WebSocketのOriginを検証する。 +失効・ログアウト・拡張無効化は既存の接続にも反映する。Cookie・WikiのBearer token・FreshRSS資格情報を +外部ページへ渡さず、中継用の秘密をURLやログに残さない。 + +接続先は公開HTTP(S)用のTCPポートに限定し、UDPや任意の管理用ポートは許可しない。 +DNS解決後の実接続先でloopback・private・link-local・metadata等を拒否し、IPv4/IPv6・DNS rebindingを +含めて検査する。接続検査だけでなくコンテナの外向き通信制限を併用し、Wiki・DB・管理ネットワークへ到達させない。 +同時セッション・ソケット・帯域・idle/接続timeoutの上限を設ける。ログは通信量・失敗分類・処理時間に限り、 +記事本文や資格情報を記録しない。HTTPSの証明書検証を無効化せず、HTML改変やTLS終端による閲覧制限回避は行わない。 + +原文クリック時だけエンジンを遅延ロードする。静的WASM資産はversion付きでキャッシュするが、 +記事本文・Cookieの永続化は初期対象外とし、上限付きのメモリプロファイルを渡す。 +固定版の`destroy()`はWASMの完全終了を保証しないため、初期実装では短時間保持を行わず、 +閉じるとiframeごと破棄する。タブ非表示が60秒続いた場合も閉じる。 +戻る/進むは最大64件のビューア内URL履歴から再読み込みし、フォームやスクロール位置は復元しない。 +上流の最小GREではSessionStoreFunctionsがなく、標準history.back()は失敗する。 +中継の接続数・転送量・拒否数は認証付きstatus/CLIで取得できる。設定UIへの監視統合と端末側計測は残件とする。 + +pthread/SharedArrayBufferのcross-origin isolationはRSSの親documentまで含めて検証する。 +COOP/COEPをWiki全体へ一律追加せず、対象ビューだけで既存の壁紙・外部リソース・共有操作への影響を確認する。 +isolation不可・端末のメモリ不足・未対応サイトではエラーと別タブ操作を示し、黙って外部中継や別タブへ切り替えない。 + +受入条件は、合成ページでのnavigation・日本語入力・検索・コピー、私有アドレス拒否・認証失効・中継停止・ +資源上限・無効化、デスクトップとiPhone SEのSafariでの初回/再表示時間・スクロール・メモリ確認とする。 +実記事での測定は明示した対象で行い、実FreshRSSの全原文や外部カレンダー・メール内容を自動巡回しない。 + +現時点ではChromiumで合成Wisp記事の描画・クリック遷移・ビューア内の戻る・接続破棄、 +接続先制限・資格情報分離・ログアウト/拡張無効化時のWebSocket終了を自動テストした。 +導入方法、資産hash、資源上限、外向きfirewallと本番前の残件は[Gecko中継の試験導入](../../operations/gecko-relay.md)にまとめる。 + ## 既読とstarの書戻し server-authoritative stateと未送信の操作を分けます。操作ごとのrequest_idで重複を防ぎ、成功応答前に確定済みと表示しません。newsboat等で同時変更された場合、古いローカルcacheをまとめて送り返しません。接続解除・認可失効時は未送信変更を勝手に再送しません。 @@ -336,6 +393,14 @@ Wiki単独は親Path配下の `rss-{request UUID}` に新規作成します。 - [ ] RSS-6:大規模利用時の公平性、host別並列上限、Retry-After/backoff、資格情報rotation UI。 - [x] RSS-7:FreshRSSの購読一覧・カテゴリを使うnavigation。同名ID分離、複数カテゴリ、cache内絞り込み、背景での原子的更新、失敗時保持。 - [x] RSS-7b:分類フォルダの継承、空フォルダ・未分類、開閉状態保存、50件ずつの購読描画、分類移動への追従。schema v6の再実行・失敗rollbackと1440px/390pxの合成試験。 +- [x] RSS-7c:Shift+j/kによるフォルダ選択。空・未分類・端・購読選択中・検索維持・入力/モーダル抑止・連打を合成試験。 +- [x] RSS-8a:Gecko端末描画+自前Wisp中継の方式決定。公開中継を使わず、独立・既定無効で導入する。 +- [x] RSS-8b1:upstream v0.0.1/hash固定、最小埋め込みと親documentのisolation、Chromiumで合成記事の描画・遷移確認。 +- [ ] RSS-8b2:Safari/iPhone SE実機、IME・コピー・find・証明書エラー・HTTPS互換性、配布license/notice整備。 +- [x] RSS-8c1:認証付きWisp TCP profile、公開IP/port制限、失効・資源上限・管理者/CLI無効化・内部status。 +- [ ] RSS-8c2:運用ホストの外向きfirewall、設定UIへの中継監視統合、負荷時の長時間受入。 +- [x] RSS-8d1:個人設定の選択、1ページのpopup閲覧、戻る/進む/再読込/別タブ/終了。 +- [ ] RSS-8d2:初回/再表示・低メモリ端末の性能評価、失敗/切断・複数タブのUX、本番配備。 隔離試験はRSS/Atom・FreshRSS login/read、欠落ID・巨大/不正feed、条件付きGET、失敗時cache保持、 本人分離・失効・readonly、二重送信・版競合・旧worker拒否、migration再実行/失敗rollback、 diff --git a/docs/operations/gecko-redistribution.md b/docs/operations/gecko-redistribution.md new file mode 100644 index 0000000..c4b8d82 --- /dev/null +++ b/docs/operations/gecko-redistribution.md @@ -0,0 +1,77 @@ +# Gecko連携の再配布条件 + +PagesWiki v0.13.0は、自作の連携コードと中継サービスのソースを配布し、Geckoエンジンは同梱しません。 +実験機能`viewer.gecko`は既定無効のままです。既存3イメージのリリースにエンジンを追加せず、 +専用relayも上流エンジンを含まないDockerfileとして提供します。 +本書は今回追加した部品の配布判断と残件を整理するもので、プロジェクト全体の法務監査ではありません。 + +## 部品と適用条件 + +| 部品 | 固定する出典・版 | ライセンスと配布時の扱い | +| --- | --- | --- | +| PagesWiki連携・Go relay | このリポジトリのリリースcommit | 自作コード。上流の実装をコピーせずWispフレーム仕様に対応。GeckoのライセンスをWiki全体へ一律適用しない | +| Go runtime / 標準ライブラリ | relayのビルドに使うGo 1.25系 | BSD-3-Clause。実ビルド環境のLICENSEを専用イメージ内`/licenses/Go.txt`へ収録 | +| golang.org/x/net | v0.35.0、WebSocket実装 | BSD-3-Clause。モジュールのLICENSEを`/licenses/golang-x-net.txt`へ収録 | +| Gecko / Mozillaの第三者コード | Firefox fork `2e1e835a5da5907e5ceef19aade58a7493f1e34d` | 主にMPL-2.0。ただし多数の個別licenseがあり、MPLだけの表示では不足。固定commitの総合noticeと該当sourceを扱う | +| gecko.js wrapper / WASM追加コード | v0.0.1 `eadcb5fa828d7e8b54ae2df13b6b3208f6553944` | 後述のMPL追加commitを確認。固定配布物にはLICENSE一式がないため、tarをそのまま再公開しない | +| Emscripten runtime / WasmFS | 6.0.1と上流のpatch | Emscripten本体はMITまたはUIUC/NCSA。libc等のruntime依存には別noticeがあるため、ツールチェーンの最上位LICENSEだけでは棚卸し完了としない | +| zstddec | 0.2.0 | npm metadataは`MIT AND BSD-3-Clause`。JS wrapperと組み込まれたdecoderの両noticeを保持 | +| Liberation fonts | 上記Firefox commit内のPDF.js standard_fonts | SIL OFL 1.1。著作権表示・OFL本文・Reserved Font Namesを保持 | + +relayのruntimeイメージは`FROM scratch`とし、Goバイナリとlicenseだけを含めます。 +Alpine/BusyBoxを新たに再配布する構成にはしません。`go list -deps`でrelayにリンクされる外部Go moduleは +`golang.org/x/net v0.35.0`のみと確認しています。ビルド用イメージと配布用runtimeイメージは区別します。 + +## 固定版とMPL宣言の関係 + +上流v0.0.1のcommitにはルートLICENSEがなく、翌日の +[`ac40f56c85060bd49dfc36ca60490f97dd270c50`](https://github.com/HeyPuter/firefox-wasm/commit/ac40f56c85060bd49dfc36ca60490f97dd270c50) +でMPL-2.0のLICENSEが追加されています。 +[固定版からの比較](https://github.com/HeyPuter/firefox-wasm/compare/eadcb5fa828d7e8b54ae2df13b6b3208f6553944...ac40f56c85060bd49dfc36ca60490f97dd270c50) +の変更はLICENSE、Makefile、README、chrome demoの2ファイルです。 +`gecko.js/js`、`gecko.js/src`、`gecko.js/lib`、`gecko.js/emsdk-patches`はこの間に変更されていません。 +この事実を追加コードのMPL宣言の根拠として記録しますが、生成された全バイナリの第三者noticeを代替するものではありません。 + +v0.0.1の[Makefile](https://github.com/HeyPuter/firefox-wasm/blob/eadcb5fa828d7e8b54ae2df13b6b3208f6553944/Makefile) +はFirefox forkのcommit `2e1e835a5da5907e5ceef19aade58a7493f1e34d`とEmscripten 6.0.1を指定しています。 +後続Makefileの参照先変更を混ぜず、再現には固定版側を使います。 + +固定版の[GRE縮小スクリプト](https://github.com/HeyPuter/firefox-wasm/blob/eadcb5fa828d7e8b54ae2df13b6b3208f6553944/gecko.js/stage-gre-min.sh) +は`chrome/toolkit/content/global/license.html`を明示的に除外し、LiberationのTTFをコピーします。 +そのため、配布tarの存在やSHA-256一致だけでnoticeの充足を判断しません。 + +Wispのwire protocolは独立実装しています。固定版エンジンは独自の`gecko.js/lib/wisp-net.js`を使います。 +pnpm-lockにある`@mercuryworkshop/wisp-js`はdemo側依存で、lockfileに記載があることだけを根拠に +PagesWiki relayの依存物・ライセンスとは扱いません。 + +## エンジンを配布する場合に必要な作業 + +MPLはファイル単位の義務であり、別実装のWiki全体をMPLへ変更するという意味ではありません。 +一方、WASMやJavaScriptを閲覧者のブラウザへ送信することも配布として扱う必要があります。 +**「イメージへ入れず、外部mountから配信すれば再配布ではない」という整理はしません。** +[Mozilla MPL FAQ Q8・Q10・Q11・Q16・Q17](https://www.mozilla.org/en-US/MPL/2.0/FAQ/)、 +[MPL 2.0本文の3章](https://www.mozilla.org/en-US/MPL/2.0/)。 + +エンジンの本番有効化・再公開前に次を完了します。 + +1. 実際の配布WASM/JS/埋め込みGREと、対応するsource・patch・依存版を照合する。 +2. Mozillaの固定commitの総合notice、MPL本文、Emscripten/runtime、zstddec、fontの各著作権・licenseを収録する。 + Mozillaの総合noticeはbuild条件による表示があるため、未処理のHTMLを置くだけで完了としない。 +3. 受領者がnoticeと対応sourceの取得先を閲覧できる画面/ファイルを用意する。 + ソースは固定commitで指し、PagesWiki側でエンジンを変更した場合は変更も含める。 +4. 提供するsourceとnoticeの可用性・保全、配布物とのhash対応を検査する。 +5. Mozillaの商標はコードlicenseとは別に扱い、Firefoxの公式配布であるとの表現やロゴの流用をしない。 + +現時点では2・3・4の配布用bundleが未完成です。今回のrelease artifactにエンジンは載せず、 +本番では中継用鍵・資産mount・`viewer.gecko`の有効化を追加しません。 +エンジン非同梱の連携コードと、通常のRSSフォルダショートカットはリリース対象です。 + +## 一次資料 + +- [Gecko forkのLICENSEと商標注意](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/LICENSE) +- [同commitのMozilla総合notice](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/toolkit/content/license.html) +- [Liberationの著作権とOFL](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/toolkit/components/pdfjs/content/web/standard_fonts/LICENSE_LIBERATION) +- [Emscripten 6.0.1 LICENSE](https://github.com/emscripten-core/emscripten/blob/6.0.1/LICENSE) +- [zstddec 0.2.0 metadata](https://registry.npmjs.org/zstddec/0.2.0) +- [Go LICENSE](https://go.dev/LICENSE) +- [golang.org/x/net v0.35.0 LICENSE](https://go.googlesource.com/net/+/refs/tags/v0.35.0/LICENSE) diff --git a/docs/operations/gecko-relay.md b/docs/operations/gecko-relay.md new file mode 100644 index 0000000..aef0b0a --- /dev/null +++ b/docs/operations/gecko-relay.md @@ -0,0 +1,149 @@ +# RSS Gecko中継の試験導入 + +RSS本文上で原文を読むための、端末側Gecko WASMと自前Wisp中継の実験機能です。 +通常の新規タブ・iframe表示は変更しません。DBスキーマ変更はありません。 +本番への自動導入・自動有効化は行いません。 + +## 構成と有効化条件 + +PagesWikiのログイン済み・activeな利用者だけが、 +`/_/api/v1/extension/organizer.feeds/browser/`以下を使います。 +同じDomainで`organizer.feeds`と`viewer.gecko`の両方が有効で、 +本体に中継URLと共有鍵ファイルが設定されていることが必要です。 +`viewer.gecko`はmanifestで既定無効です。個人設定の「RSSの記事リンクの開き方」で +Geckoを選ぶと、RSS画面だけにCOOP/COEPを追加します。選択済みでも管理者が無効化した場合は新規タブへ戻ります。 + +ブラウザには中継の鍵を渡しません。本体が認証後に30秒の署名付きgrantを発行して内部HTTP要求へ追加します。 +WebSocketではOriginも検査し、grantは一回限りです。既存接続の認証・利用者状態・拡張の有効状態は5秒間隔で再検査します。 +中継はCookie、WikiのBearer token、FreshRSSの資格情報を受け取りません。 + +## 固定するエンジン + +[HeyPuter/firefox-wasm v0.0.1](https://github.com/HeyPuter/firefox-wasm/releases/tag/v0.0.1)を使います。 +対応commitは`eadcb5fa828d7e8b54ae2df13b6b3208f6553944`です。 + +配布物`gecko.js-v0.0.1.tar.gz`のSHA-256: + +```text +bac28056a00ef6e5fb4345117e73d3629e75aca00dac71389fabbce39c018a73 +``` + +展開後の`gecko.js/dist/`をread-onlyで`/gecko`へmountします。起動時に次の両ファイルのhashを確認し、 +欠損・改変・異なる版の混在があれば中継は起動しません。 + +| ファイル | SHA-256 | +| --- | --- | +| gecko.js | e5aeebffd21106eccf23b1219316221add5e95085bc5a1bfb941117cfcd75ef7 | +| gecko.wasm.zst | ebd6c75179152624d9644865e11792ed25cadc714d9e0985f412baf9c637a086 | + +資産URLにも`assets/v0.0.1/`を含め、版をまたいだJS/WASMのcache混在を避けます。 +初回にはJSと圧縮WASMの合計38,175,359 bytes(約36.4MiB)の転送とWASMの展開・compileが必要です。 +本体のDocker buildにFirefoxのソースビルドを加えません。 + +`Dockerfile.gecko-relay`は自前の中継バイナリだけを含みます。エンジンは同梱・再配布しません。 +**エンジンをイメージへ同梱する場合だけでなく、mountした資産を利用者へ配信する前にもnoticeと対応sourceの提供が必要です。** +固定版のMPL宣言、第三者依存物、今回の配布範囲は[再配布条件](gecko-redistribution.md)を参照してください。 +v0.13.0の本番配備ではエンジンを配信せず、機能の有効化も行いません。 + +## 配置 + +任意の追加ファイル`docker-compose.gecko.yml`を通常のCompose定義に重ねます。 +このoverlayは`app`だけへ接続設定を追加し、`app2`は自動変更しません。 + +必要な環境変数: + +| 変数 | 内容 | +| --- | --- | +| PAGESWIKI_GECKO_KEY_PATH | 32文字以上の十分ランダムな共有鍵のファイル絶対Path。appとrelayへ同じread-only mount | +| PAGESWIKI_GECKO_ASSETS_DIR | hash確認した`gecko.js/dist`の絶対Path | +| PAGESWIKI_GECKO_FRONT_SUBNET | 内部接続網。既定`172.24.0.0/27`。既存LANとの重複を避ける | +| PAGESWIKI_GECKO_EGRESS_SUBNET | 中継の外向き網。既定`172.24.0.32/27` | + +鍵はイメージ、Git、コマンド引数、ログへ含めません。relayはUID/GID `10001:10001`で動きます。 +mount元ファイルをこのUIDまたはGIDで読み取り可能にし、他の利用者から読めない権限にしてください。 +本体の`PAGESWIKI_GECKO_RELAY`は内部の固定URL、`PAGESWIKI_GECKO_KEY_FILE`はmount先です。 +これらは初回参照時に読み込むため、変更・鍵ローテーション時は本体とrelayを再起動します。 + +設定確認・試験起動の例: + +```sh +docker compose -f docker-compose.yml -f docker-compose.gecko.yml config --quiet +docker compose -f docker-compose.yml -f docker-compose.gecko.yml build gecko-relay +docker compose -f docker-compose.yml -f docker-compose.gecko.yml up -d gecko-relay app +``` + +本体も今回の実装を含むイメージに更新する必要があります。既存のregistry/deploy用overrideがある場合は +それも指定し、意図せず旧イメージや開発ビルドを本番へ適用しないでください。 + +### 外向き通信の制限 + +relayは公開ポートを持たず、通常のWikiネットワークやDBデータをmountしません。 +ただしDocker bridgeの分離だけでは外向き通信を制限できません。試験導入前にホストまたは外部firewallで、 +relayのegressから管理網・社内網・metadata・Wiki/DBホストへの到達を拒否し、公開TCP 80/443と管理されたDNSだけを許可します。 +rootless Dockerとrootful Dockerでは適用点が異なるため、ホスト固有のiptablesをこのoverlayから自動変更しません。 + +アプリケーション側でもIPv4/IPv6のprivate、loopback、link-local、特殊用途アドレスを拒否します。 +名前解決で返された全アドレスを検証してから、そのIPを直接dialします。検証後の再名前解決はしません。 +UDP、80/443以外のTCP、単一ラベルのホスト名は拒否します。 +これはWisp v1フレームを用いた**制限付きTCP profile**であり、Wispの全機能互換サーバーではありません。 + +## 上限と監視 + +| 対象 | 上限 | +| --- | --- | +| 同時セッション | Domain+本人ごとに1、サービス全体4 | +| 同時TCP stream | セッションごと16 | +| 接続試行 | セッションごと256 | +| 合計転送量 | セッションごと送受信合計256MiB | +| 帯域 | セッションごと送受信合計2MiB/s、初期burst 2MiB | +| セッション期限 | 15分 | +| WebSocket受信idle | 90秒 | +| 宛先接続 | 名前解決込み8秒、個別dial 2秒 | +| relayコンテナ | 256MiB、0.5 CPU、64 PIDs、read-only、capabilitiesなし | +| 閲覧プロファイル | volatileな32MiB・2,048 entries、端末のOPFSへ永続化しない | + +relayの稼働状態・接続数・送受信bytes・拒否数は、コンテナ内の次の操作でJSON取得できます。 +鍵はファイルから読み、標準出力には含めません。counterは再起動でリセットします。 + +```sh +docker compose -f docker-compose.yml -f docker-compose.gecko.yml exec gecko-relay gecko-relay --status +``` + +`/health`は内容なしの死活確認、`/status`は署名付き内部要求だけに応答します。 +CPU・メモリはコンテナ監視を使います。設定画面の資源グラフへの統合は未完了です。 +記事URL、本文、プロファイル内容、資格情報はrelayログに記録しません。 + +## 無効化と切り戻し + +管理画面の拡張一覧で`viewer.gecko`を無効化できます。UIが使えない場合は、対象Domainを選択した +ローカル`data/pageswiki-cli`で次を実行します。 + +```text +extension viewer.gecko off +``` + +既存WebSocketは次の認証再検査時に終了します。新たな閲覧も拒否し、RSSの原文リンクは新規タブへ戻ります。 +緊急時はrelayコンテナを停止します。DB移行の巻き戻しは不要です。 + +## 受入と制約 + +自動テストでは外部アクセスしない合成Wisp応答を使い、実際のGecko WASMで描画、canvasクリックによる遷移、 +ビューア内の「戻る」、iframe削除後の接続終了を確認します。実FreshRSS、外部カレンダー、メール本文は使いません。 +専用イメージのbuildと、`--network none`・非root・read-only・資源制限付きの一時コンテナで、 +固定資産の起動時検査と`--status`も確認済みです。本番の中継・ネットワーク設定は変更していません。 + +```sh +go test -race ./internal/geckorelay ./internal/server -run 'TestGrant|TestDestinations|TestRelay|TestAssets|TestFeedGeckoAuthorization|TestFeedGeckoWebsocket' +PAGESWIKI_BROWSER_TEST=1 PAGESWIKI_GECKO_TEST_ASSETS=/verified/gecko.js/dist go test ./internal/server -run '^TestFeedGeckoChromium$' -count=1 +node internal/server/testdata/feed-gecko-profile.mjs +``` + +原文クリック時にだけ起動し、閉じるとiframe・worker・接続を破棄します。タブを60秒非表示にした場合も閉じます。 +再表示では静的資産のHTTP cacheを使えますが、エンジンは再起動します。 +戻る/進むは最大64件のURLを再読み込みする方式です。上流の最小GREにはSessionStoreFunctionsがなく、 +標準のhistory.back()が失敗するため、フォーム内容やスクロール位置を復元する履歴ではありません。 +画面のcanvasは最大1920×1080、experimental WASM JITとGPUは無効です。 + +本番の標準機能に昇格する前に、HTTPSサイトと証明書エラーの表示、Safari/iPhone SE、IME、コピー、 +find、実サイト互換性、複数タブ・起動失敗時のUX、低メモリ端末の測定、コンテナ外向きfirewallを検証します。 +外部ページのiframe拒否とは別の仕組みですが、すべてのサイトでの動作や軽さを保証するものではありません。 diff --git a/docs/operations/releases/2026-11-08-rss-gecko.md b/docs/operations/releases/2026-11-08-rss-gecko.md new file mode 100644 index 0000000..0d193e3 --- /dev/null +++ b/docs/operations/releases/2026-11-08-rss-gecko.md @@ -0,0 +1,39 @@ +# PagesWiki v0.13.0 + +RSSフォルダのキーボード移動と、既定無効のGecko原文ビューア基盤を追加するminor releaseです。 +エンジン配布を含まない範囲でリリースします。通常のRSS表示・新規タブ・sandbox iframeは維持します。 + +## 変更 + +- Shift+j/kでFreshRSSの前後の分類フォルダを選択。検索条件、未読/star絞り込みを維持。 +- 認証付きの独立Wisp TCP relayと、Gecko用の本文上popup、個人設定を実装。 +- relayは公開TCP 80/443限定、DNS解決後の全IP検査、固定IPへの接続、接続数・帯域・通信量・期限の制限。 +- ログアウト・利用者状態・拡張無効化を既存WebSocketにも反映。 +- upstream v0.0.1をhash固定。閲覧プロファイルはメモリのみ、終了時はiframeを破棄。 +- 戻る/進むは最大64件のビューア内URL履歴を再読み込み。通常ブラウザのフォーム状態復元ではない。 +- 拡張manifestの既定無効をサーバーとローカルCLIへ反映。 +- 専用relayはscratch runtimeとし、実ビルドのGo・x/netのBSD licenseを収録。 + +## 再配布と本番の範囲 + +[再配布条件](../gecko-redistribution.md)にGecko、WASM用追加コード、Emscripten、zstddec、フォントを整理しました。 +GeckoのJS/WASM/フォントをGit、通常3イメージ、release assetへ同梱しません。 +relay Dockerfileと試験用Compose overlayは提供しますが、CIの配布イメージは従来の3種類です。 + +固定版生成物にはMozillaの総合noticeが含まれないため、エンジン配布用notice/source bundleは残件です。 +外部mountからのブラウザ配信も再配布として扱い、今回の本番では鍵・asset mount・relay起動・ +`viewer.gecko`の有効化を追加しません。 +通常のRSSフォルダショートカットは利用できます。 + +## 互換性と検証 + +DBスキーマ変更はありません。RSSリンクモード`gecko`は既存preferences JSONの追加値です。 +未構成・無効時は新規タブ表示に戻り、既存利用者の設定を自動変更しません。 +旧版でpreferencesを保存する際、新しい値が残っていれば`tab`または`embedded`へ戻す必要があります。 + +Go全体テスト、関連race検査、CLI、配布ツール、Chromiumでの1440/390px RSS回帰と実Geckoによる +合成Wisp記事の描画・クリック遷移・戻る・終了を検証対象とします。実FreshRSS・外部カレンダー・メール本文は検証に使いません。 +Safari、IME/copy/find、実HTTPSの互換性と証明書エラー、低メモリ・長時間負荷、監視UI統合、 +本番の外向きfirewallは実験機能の昇格前の残件です。 + +構成・上限・切り戻しは[Gecko中継の試験導入](../gecko-relay.md)、機能の進捗は[RSS設計](../../design/ja/feeds.md)を参照してください。 diff --git a/internal/extensions/registry.go b/internal/extensions/registry.go index a1972c1..a36cea0 100644 --- a/internal/extensions/registry.go +++ b/internal/extensions/registry.go @@ -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"}, diff --git a/internal/geckorelay/NOTICE.txt b/internal/geckorelay/NOTICE.txt new file mode 100644 index 0000000..468a8eb --- /dev/null +++ b/internal/geckorelay/NOTICE.txt @@ -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. diff --git a/internal/geckorelay/access.go b/internal/geckorelay/access.go new file mode 100644 index 0000000..bdfddb6 --- /dev/null +++ b/internal/geckorelay/access.go @@ -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") +} diff --git a/internal/geckorelay/assets.go b/internal/geckorelay/assets.go new file mode 100644 index 0000000..2f20567 --- /dev/null +++ b/internal/geckorelay/assets.go @@ -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 +} diff --git a/internal/geckorelay/relay.go b/internal/geckorelay/relay.go new file mode 100644 index 0000000..5651ed8 --- /dev/null +++ b/internal/geckorelay/relay.go @@ -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 + } + } +} diff --git a/internal/geckorelay/relay_test.go b/internal/geckorelay/relay_test.go new file mode 100644 index 0000000..556b802 --- /dev/null +++ b/internal/geckorelay/relay_test.go @@ -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() +} diff --git a/internal/server/extension_state.go b/internal/server/extension_state.go index b1be7fa..e017d13 100644 --- a/internal/server/extension_state.go +++ b/internal/server/extension_state.go @@ -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 { diff --git a/internal/server/feeds.go b/internal/server/feeds.go index 802cc2e..98cc58d 100644 --- a/internal/server/feeds.go +++ b/internal/server/feeds.go @@ -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 } diff --git a/internal/server/feeds_capture_preview_test.go b/internal/server/feeds_capture_preview_test.go index 246bb86..da3e7ba 100644 --- a/internal/server/feeds_capture_preview_test.go +++ b/internal/server/feeds_capture_preview_test.go @@ -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) diff --git a/internal/server/feeds_gecko.go b/internal/server/feeds_gecko.go new file mode 100644 index 0000000..3b14a51 --- /dev/null +++ b/internal/server/feeds_gecko.go @@ -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 = `