Skip to content

Latest commit

 

History

History
325 lines (285 loc) · 24.1 KB

NETWORK.md

File metadata and controls

325 lines (285 loc) · 24.1 KB

What Qwave sends

Qwave is a sovereign browser: its thesis is that you can know, and control, what it sends. This page is the honest answer. It is written for a person, not an auditor — though the code origins are cited so an auditor can check every claim.

There are three kinds of outbound connection, and the difference matters:

  • A — Qwave's own. Code in this app decided to make the request. This is the category Qwave is fully responsible for, and the one this page holds itself to: every A connection must be justified and either user-controllable or documented here as not.
  • B — WebKit fetching a page you asked for. You navigated somewhere; WebKit loads that page and its subresources. Not Qwave's decision, but Qwave's Shields and container isolation govern it.
  • C — WebKit's own service traffic. Things the web engine may do on its own, independent of a specific navigation (fraud checks, prefetch, connectivity probes). Least visible, and the part a sovereignty claim most depends on — so it gets the most honest treatment below.

Status of this document: the Category A inventory is compiled by reading the network call sites in the codebase (origins cited). Category C is verified from WebKit's configuration in this app plus documented WebKit behaviour; full on-the-wire confirmation (mitmproxy against a local build) is a tracked follow-up, noted per row.

2026-08-15 correction. This block previously said the Category A inventory was "verified by reading every network call site". That was not true: the omnibox suggestion endpoint (duckduckgo.com) was a Category A host absent from both this table and the allowlist (#78). It is listed below now, it is on the allowlist, and an assertion in EgressGuardTests now reads the host out of the request the provider actually builds. Nothing mechanically enumerates call sites, so treat this inventory as carefully maintained rather than machine-proven — see "What the allowlist is, honestly" below the Category A table.

Preferred language and local translation

BrowserCore/ReadingLanguageRequest.swift adds the selected Accept-Language to ordinary main-frame GET navigations. The destination site sees that language preference. This does not add another destination or replay form submissions.

BrowserCore/ReadingLanguageBar.swift passes bounded page text to Apple's Translation framework on macOS 15+ / iOS 18+. Translation runs on-device; there is no Qwave remote-translation endpoint or fallback. The OS may request language model downloads. These framework-managed downloads are outside Qwave's own request builder and its endpoint allowlist; they have not been packet-capture verified. The Language menu controls automatic translation and exceptions. See coverage and restoration behavior.

Category A — Qwave's own egress

Endpoint Why When Can you turn it off? Origin
github.com/8b-is/qwave/releases/latest/download/appcast.xml Auto-update: check whether a newer signed release exists "Check for Updates…" (you click it), and — only after you consent on first run — a periodic background check Yes. Never runs before you consent; the automatic check is a setting you control. See Auto-updates. Sparkle, SUFeedURL in project.yml
api.mullvad.net VPN relay/account API Removed with the VPN layer — a tunnel is a different layer, not the browser's requirement. n/a — no such client exists —
raw.githubusercontent.com/.../easylist.txt Blocklist refresh Removed. The blocklist now ships as a committed build-time snapshot; Qwave makes no request at launch. n/a — no runtime egress Regenerated by scripts/update-blocklist.sh
api.x.ai/v1 (the default endpoint) Memory Wave: summarise / ask over your own captured pages Only when you invoke Summarize/Ask and have turned on the OpenAI-compatible provider and entered a key Yes — off by default (providerKind defaults to .onDevice; the remote provider requires explicit selection). Local inference does not send the prompt to this endpoint. When you do invoke it, the page text itself is what goes to the endpoint — see the note below the table. MemoryWave/MemoryProvider.swift; default in MemoryWavePreferences.swift:14,32-37
Any HTTPS endpoint you type in (self-hosted Ollama / LM Studio / vLLM, a personal gateway, another vendor) Same as above, but pointed wherever you choose Same as above Yes — you chose it. HTTPS is required (MemoryWavePolicy denies a non-HTTPS base URL). Settings states the egress at the moment of consent: "Pages you summarise or ask about with this provider are sent to this endpoint." A cross-host redirect is refused, so the page text cannot be replayed to a host you did not configure. The host you configure is also the only non-committed host EgressGuard will let Memory Wave's own provider request reach — exact match, resolved against the preference at the moment of the request, so changing or disabling the endpoint revokes the previous host on the spot. It is permitted for that request, not for the process: no other client in Qwave gains it. MemoryWavePane.swift:52 (consent copy); MemoryProvider.swift EndpointRedirectPolicy; MemoryWavePolicy.swift:83-85 (#88); mark at MemoryProvider.swift:108, check at EgressGuard.swift:236
duckduckgo.com/ac/ Omnibox autocomplete: suggestions for what you are typing Only while you type in the omnibox, and only if you turned network suggestions on and DuckDuckGo is your chosen engine Yes — off by default (networkSuggestionsEnabled defaults to false). Off means on-device suggestions only — history, bookmarks, open tabs, actions — and nothing leaves the Mac. When on, the transport is deliberately cookieless and ephemeral (no cookie storage, 3 s timeout), so the query carries no session identity. transport BrowserCore/SearchSuggestionProvider.swift (SuggestionTransport); call site BrowserWindowController.swift (engine-gated); engine mapping SearchSuggestionProviderFactory
ac.ecosia.org/autocomplete Omnibox autocomplete: suggestions for what you are typing Only while you type in the omnibox, and only if you turned network suggestions on and Ecosia is your chosen engine (it is the default) Yes — off by default, same gate as the DuckDuckGo row: cookieless, ephemeral, 3 s timeout. Ecosia and DuckDuckGo are the only engines Qwave ships, for exactly this reason — both have a vetted keyless autocomplete endpoint. transport BrowserCore/SearchSuggestionProvider.swift (EcosiaSuggestionProvider); allowlist QwaveSupport/EgressAllowlist.swift and core/src/egress.rs
The relay's in-tunnel gateway (10.64.0.1, inside the VPN) Post-quantum key exchange for the VPN tunnel Removed with the VPN layer n/a — no such client exists —
The favicon URL of a site you visit Show the site's icon in the tab When you load a page Tied to browsing. Fetched with a cookie-free, storage-free session and cached per container, so a favicon fetch can never carry one container's identity into another. Sources/QwaveApp/FaviconLoader.swift
A .md/directory URL you navigate to Render remote markdown in the reader When you navigate to a markdown document Tied to that navigation — it fetches exactly the document you asked for, and only after WebKit has already fetched a response from that host. Exempt from the allowlist by an explicit EgressGuard.markPageDriven(_:) marker, not by accident. BrowserCore/NavigationCoordinator.swift

What Memory Wave actually sends to a remote provider

Precisely, because this is the row people care most about:

  • The page text goes. "Summarize Page" sends the extracted article body, clamped to 12,000 characters, in the prompt (WaveDirector.swift:320-323 → ArticleExtract.clamped() at MemoryRecord.swift:94, MemoryWaveConstants.maxPageCharacters). "Ask" appends the same clamped page text to your question (WaveDirector.swift:360-363). If you would not paste a page into that provider's web UI, do not Summarize it with that provider configured.
  • Stored memory bodies never go — by a declared-intent gate plus a caller-side guard. Worth being precise about what each half does. MemoryWavePolicy.decide is a pure function over a context the caller supplies: when that context says the provider is remote and includeStoredMemory is true, it returns .deny(.cognitiveEgress) and the request is refused before it is built (MemoryWavePolicy.swift:81-82). It therefore catches a caller that declares it is carrying stored memories; it never inspects the prompt, so it cannot see a caller that attaches them without declaring. What actually keeps recalled memories out of a remote prompt is WaveDirector's own guard — the recall block is composed into the prompt only when provider.kind == .onDevice (WaveDirector.swift:415-421). The context handed to the policy is built by the same infer (WaveDirector.swift:400-410); ask sets includeStoredMemory only for the on-device provider (WaveDirector.swift:364), and summarize (:326) and summarizeTimeline (:210) never ask for it at all. Both halves hold with a remote provider configured and a key entered. Say plainly which half is load-bearing: the caller-side guard is. The policy is a tripwire behind it, dormant in normal operation precisely because ask never declares the dangerous pair — it is what fails if a future caller does. infer hands it the intent as declared, without pre-filtering, or it could not be tripped at all.
  • Recalled memories are split by provenance before they reach a prompt. Rows a model wrote (.summary) or an automatic page capture produced (.browse) are marked derived at the write site and rendered under a separate "Untrusted recalled content" heading that tells the model to treat them as quoted data, rather than beside the pins you wrote yourself (WaveDirector.recalledMemoryBlock, WaveDirector.swift:49-70; column added at MemoryStore.swift:388). That is a prompt-position boundary, not an egress one — it applies to the on-device prompt, which is the only prompt recalled memories are composed into at all.
  • Timeline summaries are the titles-and-times case. Summarising your timeline with a remote provider sends time, title, and host per entry and omits every page snippet (includeSnippets: !remote, WaveDirector.swift:199-200; MemoryTimeline.swift:63-80).

Reading this table: after the launch-fetch removal, every Category-A connection is either off-by-default, VPN-gated, user-consented, or a direct consequence of a page you asked for. The tested shields preparation path makes no request through URLSession.shared. This is a scoped assertion, not a guarantee of no network traffic during app startup: EgressGuardTests registers a URLProtocol recorder (EgressGuardTests.swift:705-713), drives the shields launch path, and asserts zero requests were observed (testShieldsLaunchPathMakesNoNetworkRequest, EgressGuardTests.swift:716-738).

Its reach, stated exactly, because it is narrower than "no egress at launch". The recorder is installed with URLProtocol.registerClass, which reaches URLSession.shared and nothing else. A URLSession you construct never consults it — not even one built from URLSessionConfiguration.default, which earlier wording here implied was covered. That includes the ephemeral DuckDuckGo suggestion session (SearchSuggestionProvider.swift:59-69), Memory Wave's provider session (MemoryProvider.swift:49-55) and FaviconLoader's (FaviconLoader.swift:20-24) — the first two reach the guard only because they call EgressGuard.install(into:) themselves. WebKit's own network process is out of reach for the same structural reason, which the test file already states (EgressGuardTests.swift:58-66). And the test constructs its own ShieldsDirector (:727-730) rather than running the app's launch sequence, so it asserts over the shields preparation path specifically, not over everything the app does at startup. It is no longer the only dynamic assertion in that suite — the guard's block/allow behaviour (:204-244), the suggestion host read out of a real request (:139-152), the page-driven markdown exemption (:528-572, :577-600), the user-configured endpoint's reach and revocation (:339-483) and registerClass's actual reach (:614-637) are all exercised through real URLSession machinery — but it is still not a process-wide egress monitor.

What the allowlist is, honestly. The committed allowlist of permitted hosts is now backed by a real runtime enforcement point, EgressGuard: a URLProtocol that consults EgressAllowlist.permits(host:) and fails any request whose host is not listed, wired into every fixed-host Qwave client — MullvadAPIClient (via URLSession.mullvadPinned()), the DuckDuckGo suggestion provider, and, through a process-wide URLProtocol.registerClass at launch, any client that uses URLSession.shared. Memory Wave's remote provider joined that list only now — see below for what its absence meant. duckduckgo.com is on the allowlist as of this change (#78) precisely because runtime enforcement would otherwise break the opt-in suggestion feature the moment someone turned it on.

This closes the runtime half of #77, but it is still not a mechanical guarantee over the whole codebase, and CI still runs the same hand-written assertions pinning four known endpoint hosts (MullvadAPIClient().baseURL, MemoryWavePreferences.defaultRemoteBaseURL, the literal github.com at EgressGuardTests.swift:97-102, and a literal duckduckgo.com/ac/ URL at EgressGuardTests.swift:109-115) plus a rejection test for unknown hosts. One assertion is not a restated literal: testSuggestionEndpointHostIsAllowlisted reads the omnibox suggestion host out of the request DuckDuckGoSuggestionProvider actually builds (a capturing URLProtocol on an injected session), so it fails if that call site's URL changes to a host nobody reviewed. It exists at all only because the test target now depends on BrowserCore: it did not until #78, so no assertion in this suite could reach the provider even in principle, which is the sharper reason duckduckgo.com went unseen for a whole release. Nothing enumerates network call sites, so a new fixed-host URLSession client that does not call EgressGuard.install(into:) is not caught — a reviewer still has to notice it and wire it up, same as before. And by design EgressGuard does not gate every Category-A client: FaviconLoader and the remote-markdown fetch are page-driven rather than a fixed set of hosts. See EgressGuard's doc comment for the full, per-client rationale.

Memory Wave's provider used to head that exclusion list, and that was the gap, not a design. The stated reason — its base URL is user-configurable to any HTTPS endpoint, so it cannot be pinned to a committed list — was true of the committed list and true of nothing else. Its session is built from URLSessionConfiguration.ephemeral and never called EgressGuard.install(into:), so the guard had never blocked, permitted, or observed a single provider request: api.x.ai was on the allowlist as a comment. It is gated now. The user-configurable half is carried per request: OpenAICompatibleProvider marks its own request with EgressGuard.markUserConfiguredEndpoint(_:) — the same shape as the page-driven marker below — and the guard permits it only if it is going to the host you have configured right now, exact match (unlike the committed list, which matches subdomains: typing example.com is not consent for telemetry.example.com). So the guard permits the committed hosts, plus, on Memory Wave's own request only, the one host you configured.

Two properties of that shape are worth being explicit about, because the first draft of this change kept the host in a process-wide slot and got both wrong.

Revocation is immediate. Settings writes providerKind / remoteBaseURL to MemoryWavePreferences and calls nothing else — no provider is rebuilt, and if you have just switched Memory Wave off there may be no next inference ever. A permission published when a provider is built would therefore have left the previous host permitted, potentially for the life of the process. The guard instead reads MemoryWavePreferences.egressPermittedHost at check time (through a closure installed once in BrowserEnvironment, so QwaveSupport does not depend on MemoryWave). Nothing is cached, so nothing can go stale. Uninstalled, that closure reports no host and a configured endpoint is refused: the failure mode is closed.

It is not a process-wide permission. The endpoint you typed for Memory Wave is not added to EgressAllowlist, which stays purely the committed list. Only a marked request may reach it — not URLSession.mullvadPinned(), not the DuckDuckGo suggestion session, not anything on URLSession.shared. Unlike markPageDriven(_:), the mark grants nothing on its own: it cannot name a host, so a caller cannot use it to reach anywhere except the endpoint you configured.

EndpointRedirectPolicy and MemoryWavePolicy (#88) still do what they always did — refuse a redirect off the configured origin, and refuse a request that declares it carries stored memories — neither of which was ever a host check.

Page-driven requests use explicit boundaries. FaviconLoader constructs its own session and never installs the guard. Remote Markdown constructs a fresh ephemeral session for each re-fetch and explicitly installs the guard. EgressGuard.markPageDriven(_:) marks the navigated document request and each HTTP(S) redirect, so it remains usable on hosts outside the fixed allowlist. No host or entire session is exempted.

The request jar is seeded only from the initiating web view's cookie store. Foundation applies domain, path and Secure matching at each hop; response cookies stay in that disposable jar and are never copied back to WebKit. The original WebKit navigation owns browser cookie updates. This prevents a late/cancelled reader re-fetch from mutating browser cookies. There is no URLCache or URLCredentialStorage, even for ordinary tabs. Sessions are invalidated when finished or cancelled, with a 20-second idle timeout, 45-second resource timeout and 8 MiB response limit. HTTP-auth and client certificate credentials cannot be imported from WebKit; these challenges fail rather than using another context's stored credentials. TLS validation still uses the system default. Credential-bearing and non-HTTP(S) URLs are refused.

Being straight about the cost, since a page-driven exemption is a hole in the guard by construction: any caller that applies the marker bypasses the allowlist, and only review stops one from doing so. Two things bound it. It is per request, not per host or per session — URLSession.shared stays gated for everything else, and an unmarked request to the very same host is still refused (both pinned by testPageDrivenExemptionDoesNotExemptTheHostOrTheSession). The initiating request is tied to browser navigation: the fetch runs from decidePolicyFor navigationResponse, i.e. after WebKit has already connected to that host and received response headers, so the marked request re-fetches a document the browser just retrieved because you asked it to.

Category B — pages you asked for

When you navigate somewhere, WebKit fetches that page and whatever it embeds (images, scripts, fonts, XHR/fetch the page makes). Qwave does not add to or subtract from the set of things the page itself requests, except to block:

  • Shields apply a ~59k-rule EasyList content blocker plus per-site JavaScript control, so many third-party trackers a page would otherwise load never connect at all.
  • HTTPS-First rewrites http:// main-frame loads to https://.
  • Containers keep cookies/storage separate per container, and burner (ephemeral) tabs keep nothing.

This is the traffic you initiate by browsing. Qwave's job here is to shield it, not to add to it.

Category C — WebKit's own service traffic

These are things the web engine can do on its own. Qwave configures WebKit, so what is on and off is Qwave's responsibility to disclose even though the requests originate inside WebKit.

Behaviour On? What it means Follow-up
Fraudulent-website warning (Safe Browsing) On WebKit checks sites you visit against a fraud/malware database. On Apple platforms this contacts Apple's Safe Browsing service (Apple proxies Google/Tencent Safe Browsing so the provider never sees your IP, but Apple's servers receive hashed URL prefixes for hosts you navigate to). It protects against phishing; it is also egress on navigation. Whether to expose an off switch (WebKit's isFraudulentWebsiteWarningEnabled is a per-configuration flag Qwave already sets) is an open product decision. On-the-wire confirmation of exactly what is sent needs a mitmproxy sweep — tracked.
Known-hosts HTTPS upgrade On WebKit upgrades known HSTS hosts to HTTPS using a built-in list shipped with the engine. No network request — it is a local lookup. None — local only.
DNS prefetch / speculative connections Engine default WebKit may resolve or preconnect to hosts a page hints at (rel=dns-prefetch/preconnect). Driven by page content, so effectively Category B, but initiated speculatively. Confirm scope empirically in the same mitmproxy sweep.

The honest statement: the fraudulent-website warning is on, and it is the one piece of Qwave's network behaviour that talks to a third party (Apple) on navigation without an explicit per-visit choice. It is a real anti-phishing protection, not telemetry — but a sovereignty-first browser should let you decide. That decision, and the empirical confirmation of exactly what crosses the wire, is the next piece of work after this inventory.

Auto-updates

Qwave uses Sparkle, and the consent chain is:

  1. Nothing checks before you say so. SUEnableAutomaticChecks is deliberately not set, so Sparkle asks your permission (its standard prompt) before it ever checks automatically. No update request fires until you've answered.
  2. You can change your mind, visibly. Settings → General → "Check for updates automatically" toggles it any time. Off means zero background update requests — the only way an update check happens is you choosing "Check for Updates…" from the menu.
  3. Only one host, and it's allowlisted. Update checks reach exactly github.com (the signed appcast); that host is on the committed egress allowlist, and EgressGuardTests.testSparkleFeedHostIsAllowlisted asserts it stays there (note the scope described above — the assertion is over the host string, not over Sparkle's fetch).
  4. Updates are EdDSA-signed — a compromised host cannot serve a forged update without the private key.

Blocklist updates

The ~59k-rule blocklist ships as a committed build-time snapshot, regenerated by scripts/update-blocklist.sh and reviewed as a normal diff. There is no launch-time fetch and no runtime blocklist egress. (An earlier build fetched the upstream EasyList at every launch and discarded the result — egress that bought the user nothing; that has been removed.) See docs/BLOCKLIST.md.


If the honest answer to any row is "we send this and you cannot turn it off", this page says so. A disclosed limitation is worth more than an omitted one.

Published as part of the 8b.IS Documentation Hub and 8b-public-documents.