From f6046cc6c5ef875ec60128edb28c0e1544217878 Mon Sep 17 00:00:00 2001 From: Anthony Ronning <101225832+AnthonyRonning@users.noreply.github.com> Date: Wed, 18 Nov 2026 13:03:00 -0800 Subject: [PATCH 1/3] OpenSecret: remove Transport V1 Transport V2 has been the only transport the in-tree SDKs speak since September 14 (Research 3.4.0, SDK 4.0). The backend still served V1 beside it: the application router was mounted on the listener as well as behind the V2 gateway, and nearly every boundary carried a second, weaker branch for it. This removes that branch everywhere. The listener now serves only /health-check, the public attestation document, the relay fleet's admission check and the two /v2 endpoints. Application routes are reachable only inside a V2 envelope, and each one refuses a request the gateway did not decrypt: only the gateway can attach the in-process session marker, and authentication reads only the credential the envelope carried, never an outer header. Removed with it: - POST /key_exchange, the per-nonce ephemeral keys, the V1 session store and its maintenance task, per-field request and response encryption, and per-event SSE encryption; - the V1 access and refresh token audiences. Nothing issues or accepts them; they stay reserved against third-party tokens; - unbound OAuth authorization URLs and state. Every redirect is bound to its initiating session with PKCE or the Apple nonce; - the operator-computable provider cache namespaces. A completion without a cache root is refused; - the lenient end-of-stream rule that accepted a provider stream without [DONE] after a finish signal; - the route and handler gates that existed only to reject V1 sessions on recovery, password-reset and remote routes. GET /attestation/{nonce} stays, as a public attestation document rather than a handshake: it attests no key and stores no state. The apps' verification page and deployment checks read it. Handler call sites keep their names (decrypt_request, encrypt_response, TransportSession); only what is underneath them changed. Clients older than Research 3.4.0 or SDK 4.0, including older proxy builds, cannot use a backend built from this commit. Co-Authored-By: Claude --- .agents/skills/change-opensecret-api/SKILL.md | 12 +- .../change-opensecret-provider/SKILL.md | 4 +- .../validate-opensecret/references/checks.md | 15 +- .../scripts/disposable_db_tests.sh | 8 +- services/opensecret/README.md | 2 +- services/opensecret/docs/local-macos-stack.md | 3 +- services/opensecret/docs/oauth-callbacks.md | 3 +- services/opensecret/docs/transcription.md | 3 +- .../opensecret/docs/transport-v2-protocol.md | 129 ++-- .../opensecret/src/aead_db_tamper_tests.rs | 2 +- services/opensecret/src/bounded_ttl_cache.rs | 278 ++----- services/opensecret/src/encrypt.rs | 44 -- services/opensecret/src/inference.rs | 1 - services/opensecret/src/jwt.rs | 227 +++--- services/opensecret/src/lease_aware_cache.rs | 713 ------------------ services/opensecret/src/main.rs | 310 +------- services/opensecret/src/oauth.rs | 369 +++------ .../src/password_policy_route_tests.rs | 4 +- services/opensecret/src/provider_cache.rs | 60 +- .../opensecret/src/recovery_route_tests.rs | 190 +---- .../src/secret_cache_maintenance.rs | 76 -- .../opensecret/src/security_invariants.rs | 164 ++-- .../src/transport_v2/client_app_tests.rs | 5 +- .../opensecret/src/transport_v2/gateway.rs | 13 +- .../src/transport_v2/oauth_callback_tests.rs | 286 +++---- .../transport_v2/recovery_transport_tests.rs | 161 ++-- .../opensecret/src/web/attestation_routes.rs | 155 +--- .../src/web/encryption_middleware.rs | 685 ++++------------- services/opensecret/src/web/login_routes.rs | 111 +-- .../src/web/native_handoff_routes.rs | 5 +- services/opensecret/src/web/oauth_routes.rs | 132 ++-- services/opensecret/src/web/openai.rs | 463 +++--------- .../opensecret/src/web/openai/maple_tests.rs | 149 ++-- services/opensecret/src/web/openai_auth.rs | 77 +- .../src/web/platform/login_routes.rs | 95 +-- .../opensecret/src/web/protected_routes.rs | 101 +-- services/opensecret/src/web/remote/mod.rs | 12 - .../opensecret/src/web/responses/handlers.rs | 28 +- .../src/web/responses/image_describer.rs | 2 +- services/opensecret/src/web/system_one.rs | 2 - .../src/web/system_one/decisions.rs | 9 +- 41 files changed, 1149 insertions(+), 3959 deletions(-) delete mode 100644 services/opensecret/src/lease_aware_cache.rs delete mode 100644 services/opensecret/src/secret_cache_maintenance.rs diff --git a/.agents/skills/change-opensecret-api/SKILL.md b/.agents/skills/change-opensecret-api/SKILL.md index 79ec64fed..255f551e3 100644 --- a/.agents/skills/change-opensecret-api/SKILL.md +++ b/.agents/skills/change-opensecret-api/SKILL.md @@ -36,9 +36,10 @@ module as the authority for inner session/decryption middleware. Use `src/web/responses/` for Responses, conversations, tools, persistence, and events. -For Transport V2, also trace `src/transport_v2/gateway.rs` and -`src/transport_v2/session.rs` from the mounted routes in `src/main.rs`. -V1 and V2 transport coexist; establish which path the actual SDK invokes. +Transport V2 is the only client transport. Trace +`src/transport_v2/gateway.rs` and `src/transport_v2/session.rs` from +`public_routes` in `src/main.rs`: application routes are mounted only inside +the gateway (`transport_v2_application`), never on the listener. Transport V2 and Router V2 are separate mechanisms, so a transport version does not establish the selected inference router. @@ -49,7 +50,7 @@ does not establish the selected inference router. route-appropriate auth context. - A session protects transport; it does not establish user identity, project membership, or storage-key ownership. Bodyless protected routes still - validate and touch the session. + require a live session. - JWT and API-key contexts are distinct. Preserve the auth method through authorization, persistence eligibility, quota, and usage attribution. - Hold the session lease for the complete response body or stream. Successful @@ -59,8 +60,7 @@ does not establish the selected inference router. selected session or auth failures by retrying, so a side-effecting change needs explicit idempotency or proof that validation precedes the effect. -Inspect `src/web/attestation_routes.rs`, -`src/web/encryption_middleware.rs`, session state in `src/main.rs`, +Inspect `src/web/encryption_middleware.rs`, `src/transport_v2/session.rs`, `src/web/openai_auth.rs`, and `src/jwt.rs` when the change reaches those boundaries. Do not duplicate their policy inside a handler. diff --git a/.agents/skills/change-opensecret-provider/SKILL.md b/.agents/skills/change-opensecret-provider/SKILL.md index ab5656cf3..2a1e090ac 100644 --- a/.agents/skills/change-opensecret-provider/SKILL.md +++ b/.agents/skills/change-opensecret-provider/SKILL.md @@ -69,8 +69,8 @@ call site's unavailable, timeout, denial, fallback, and success semantics. Completion requests use Router V2. Keep image and title helpers on the request's authenticated account and plan routing context. A helper candidate identifies a public model; resolve its provider through shared routing rather than pinning -an independently guessed provider. Router retirement does not remove Transport -V1 or change the public API versions. +an independently guessed provider. Router retirement does not change the +public API versions. Trace alias resolution separately from model selection and provider selection. Router V2 resolves an Auto alias to its tier's preferred model, then diff --git a/.agents/skills/validate-opensecret/references/checks.md b/.agents/skills/validate-opensecret/references/checks.md index c18d31cbe..28fe76701 100644 --- a/.agents/skills/validate-opensecret/references/checks.md +++ b/.agents/skills/validate-opensecret/references/checks.md @@ -73,13 +73,14 @@ OPENSECRET_DEV_POSTGRES=0 OPENSECRET_DEV_ENV=0 OPENSECRET_DEV_CONTAINERS=0 \ The helper proves an empty-database migration and the selected local synthetic database suites, including OAuth settings preservation, callback selection, -and Google/GitHub callback completion through the real V1 encryption -middleware and V2 gateway. Completion tests exchange synthetic credentials -only with local mock token/user-info endpoints, verify the originally selected -callback after settings change, and reject replay without another exchange. -The recovery subset covers recovery-wrap lifecycle, management and V2 -password-reset routes, and a recovery flow through the real V1 middleware and -V2 gateway; its reset rows use a known code MAC instead of email delivery. +and Google/GitHub callback completion through the real Transport V2 gateway. +Completion tests exchange synthetic credentials only with local mock +token/user-info endpoints, verify the originally selected callback after +settings change, refuse a callback from another session, and reject replay +without another exchange. The recovery subset covers recovery-wrap lifecycle, +management and V2 password-reset routes, and a recovery flow through the real +gateway that also proves the listener serves no recovery route in plaintext; +its reset rows use a known code MAC instead of email delivery. The `os-sdk-e2e` lane in `ci.yml` runs this helper too. These fixtures do not prove a live OAuth provider flow, a released SDK or application, or a data conversion from representative old rows. diff --git a/.agents/skills/validate-opensecret/scripts/disposable_db_tests.sh b/.agents/skills/validate-opensecret/scripts/disposable_db_tests.sh index 30ba67233..a470aba80 100755 --- a/.agents/skills/validate-opensecret/scripts/disposable_db_tests.sh +++ b/.agents/skills/validate-opensecret/scripts/disposable_db_tests.sh @@ -238,7 +238,7 @@ grep -Eq "test result: ok\\. ${compaction_count} passed; 0 failed; 0 ignored;" \ callback_count=0 for callback_filter in \ db::tests::db_oauth_settings_ \ - transport_v2::gateway::tests::db_oauth_callback_selection_v1_v2 \ + transport_v2::gateway::tests::db_oauth_callback_selection \ transport_v2::gateway::tests::db_oauth_callback_completion_; do cargo test --locked --all-features "$callback_filter" \ -- --ignored --list >"$workdir/callback-tests.list" @@ -247,8 +247,8 @@ for callback_filter in \ END { print count + 0 }' "$workdir/callback-tests.list")" test "$selected_count" -gt 0 if [ "$callback_filter" = "transport_v2::gateway::tests::db_oauth_callback_completion_" ]; then - # Both Google and GitHub must complete through both encrypted transports. - test "$selected_count" -eq 4 + # Both Google and GitHub must complete through the gateway. + test "$selected_count" -eq 2 fi cargo test --locked --all-features "$callback_filter" \ @@ -267,7 +267,7 @@ done recovery_count=0 for recovery_suite in \ recovery_db_tests::=12 \ - recovery_route_tests::=31 \ + recovery_route_tests::=30 \ transport_v2::gateway::tests::db_recovery_=1; do recovery_filter="${recovery_suite%=*}" expected_count="${recovery_suite##*=}" diff --git a/services/opensecret/README.md b/services/opensecret/README.md index 244f25094..a044db700 100644 --- a/services/opensecret/README.md +++ b/services/opensecret/README.md @@ -88,7 +88,7 @@ OPENSECRET_DEV_POSTGRES=0 OPENSECRET_DEV_ENV=0 OPENSECRET_DEV_CONTAINERS=0 \ The Rust unit-test job does not run ignored tests. The SDK integration job also runs the disposable-database helper, including OAuth settings and -encrypted V1/V2 callback-selection checks. Live-provider tests remain separate. Use the +encrypted callback-selection checks. Live-provider tests remain separate. Use the [`validate-opensecret`](../../.agents/skills/validate-opensecret/SKILL.md) workflow for disposable PostgreSQL tests, authorized provider checks, encrypted-client smoke tests, Nix checks, and release-only EIF/PCR evidence. Report those layers diff --git a/services/opensecret/docs/local-macos-stack.md b/services/opensecret/docs/local-macos-stack.md index 421f63ab8..cfec7bd97 100644 --- a/services/opensecret/docs/local-macos-stack.md +++ b/services/opensecret/docs/local-macos-stack.md @@ -21,8 +21,7 @@ The Continuum proxy deliberately has no shared prompt-cache default. OpenSecret injects user-bound `cache_salt` values into completion requests; explicit salts enable reuse without `--sharedPromptCache`. Do not add a proxy-wide salt to the launch command. See the -[provider cache contract](transport-v2-protocol.md#provider-cache-root) for -V1/V2 scope and restart behavior. +[provider cache contract](transport-v2-protocol.md#provider-cache-root). ## One-time setup diff --git a/services/opensecret/docs/oauth-callbacks.md b/services/opensecret/docs/oauth-callbacks.md index 77c9955f2..591b1c4d4 100644 --- a/services/opensecret/docs/oauth-callbacks.md +++ b/services/opensecret/docs/oauth-callbacks.md @@ -50,8 +50,7 @@ enabled flags and other provider settings retain their existing semantics. The decrypted request body for `/auth/github`, `/auth/google`, and `/auth/apple` accepts an optional `redirect_url` alongside the existing -`client_id`. The same contract applies through both -Transport V1 and Transport V2. +`client_id`. When absent or `null`, the provider's default `redirect_url` is used. When present, the value must exactly match the default or one of that provider's diff --git a/services/opensecret/docs/transcription.md b/services/opensecret/docs/transcription.md index 104c5b7ee..c3e6bc438 100644 --- a/services/opensecret/docs/transcription.md +++ b/services/opensecret/docs/transcription.md @@ -43,8 +43,7 @@ The app records 16 kHz mono PCM16 WAV. Ten minutes is about 19.2 MB of audio; twenty minutes is about 38.4 MB. Both fit the SDK's 50 MiB Transport V2 JSON-body limit after base64 encoding. Thirty minutes is about 57.6 MB of audio and 76.8 MB of base64, so the existing SDK rejects it before upload. Enclave-side compression -or splitting cannot change that ingress limit. Transport V1's additional base64 -envelope is more restrictive. +or splitting cannot change that ingress limit. Provider duration agreement confirms reported audio processing, not transcript accuracy or completeness of recognized speech. Use the real-audio validation diff --git a/services/opensecret/docs/transport-v2-protocol.md b/services/opensecret/docs/transport-v2-protocol.md index 62b6c2d63..14c48527b 100644 --- a/services/opensecret/docs/transport-v2-protocol.md +++ b/services/opensecret/docs/transport-v2-protocol.md @@ -1,8 +1,8 @@ # OpenSecret Transport V2 -This document is the canonical wire contract for Transport V2. It describes -the protocol implemented by `src/transport_v2/` and the V2-specific -authentication paths. Older design notes are useful research, but are not +This document is the canonical wire contract for Transport V2, the only client +transport OpenSecret serves. It describes the protocol implemented by +`src/transport_v2/` and its authentication paths. Older design notes are useful research, but are not normative when they disagree with this document or the source. Transport V2 is deliberately small: @@ -12,7 +12,8 @@ Transport V2 is deliberately small: - every request carries its own credential, when one is required; - a random request ID provides unordered, exact replay detection; - responses are ordered authenticated records with explicit finality; and -- V1 remains a separate protocol with unchanged wire behavior. +- the application is reachable no other way: Transport V1 is + [retired](#transport-v1-is-retired). It does **not** use a principal-bound session, EHBP, DPoP, Binary HTTP, monotonic request counters, per-field signatures, or a custom memory scheduler. @@ -262,8 +263,9 @@ inside the encrypted response; subsequent authenticated requests carry the appropriate token inside their own envelope. The transport session itself does not change state during this transition. -V2 user and platform access/refresh tokens have dedicated audiences that V1 -validators do not accept. Third-party JWT issuance remains an authenticated +V2 user and platform access/refresh tokens have dedicated audiences. The +audiences of the retired Transport V1 session tokens are accepted nowhere and +stay reserved, so a third-party token can never carry one. Third-party JWT issuance remains an authenticated application operation; those tokens are outputs for external services, not V2 transport credentials. @@ -309,12 +311,8 @@ Privatemode's cache-affinity shard header includes a stable hash prefix of the salt, allowing its API gateway to correlate requests while that namespace is unchanged. Cache isolation therefore does not provide request unlinkability. -Legacy V1 clients do not supply a cache root. OpenSecret derives their Continuum -salts with the Continuum label and verified user UUID, keyed by a random -32-byte secret held only in the backend process. Those salts remain stable -within that process; restart or a different backend replica cold-starts the -namespace. No database migration or additional configured secret is required. -Legacy Tinfoil's `SHA-256(user UUID)` behavior is unchanged. +A completion request without a root is refused. There is no fallback +namespace, so none can be computed from the user identifier alone. ### Request record encryption @@ -483,10 +481,10 @@ For example, usage exhaustion returns Other application and provider errors retain their existing body shape. These codes grant no automatic replay permission and request neither a new session nor token refresh. V2 authenticates the logical status, headers and body inside -its outer HTTP 200 response; V1 retains its existing HTTP error representation. +its outer HTTP 200 response. -Retained flat fields preserve legacy V1 message parsers, while the nested error -is readable by existing OpenAI clients over V2. Research clients using +Retained flat fields preserve existing message parsers, while the nested error +is readable by existing OpenAI clients. Research clients using structured status/code classification against backends without these additions can still encounter the flat-body V2 parsing problem; supporting that combination requires separate client adaptation. This contract does not change @@ -500,8 +498,7 @@ OpenAI-compatible `error` described above: the same `message`, the static `code`, and a `type` of `invalid_request_error` for 4xx or `server_error` otherwise. The code is also carried by `x-opensecret-error-code`, alongside `x-opensecret-error-contract: 1`. V2 authenticates the logical status, headers -and body; V1 uses its existing HTTP error representation with the classified -status/message. +and body. | Failure | Public HTTP status | Error code | | --- | --- | --- | @@ -643,8 +640,8 @@ the exact attested session across the browser redirect. The Apple front-channel ID token is not the proof used here; verification uses the signed ID token from the token endpoint. This redirect proof does not replace `/auth/apple/native`: that route verifies the submitted signed identity token and preserves its -existing optional client-provided nonce behavior. V1 keeps its existing OAuth -URL and state behavior. +existing optional client-provided nonce behavior. Every redirect authorization +is bound this way; there is no unbound authorization URL or state. ## Refresh, retry, and downgrade rules @@ -671,7 +668,7 @@ above. The resend uses the new session and a fresh request ID; a second failure is returned to the caller. This applies to ordinary managed requests including mutations and inference, not just reads. -This deliberately matches V1's best-effort session recovery behavior. An +Session recovery is deliberately best-effort. An untrusted intermediary can let the original request execute, replace its response with a forged recovery hint, and cause the client to submit the operation again under a new session. The per-session replay set cannot prevent @@ -686,13 +683,11 @@ the original operation is still returned as failed. A lost response remains an ambiguous outcome. Prepared native-handoff redemption and session-bound OAuth callbacks cannot move to a fresh session; their flows must restart instead. -V2 clients do not fall back to V1 when session establishment or a request -fails. The narrow recovery hints never authenticate response content or permit -plaintext credentials; logical credentials remain inside the encrypted resend. -V1 and V2 use separate session stores, record formats, and internal token -audiences. Existing -raw API keys remain the same inference-only application capability across both -transports; the transport does not rotate them. +There is no other transport to fall back to when session establishment or a +request fails. The narrow recovery hints never authenticate response content or +permit plaintext credentials; logical credentials remain inside the encrypted +resend. Raw API keys remain an inference-only application capability; the +transport does not rotate them. ## Native application handoff @@ -720,31 +715,48 @@ session replay set prevents duplicate redemption within the live session. Prepared redemption does not use managed session-recovery retries: losing its bound session requires a new handoff and grant. -## V1 compatibility - -Transport V2 is an additive network boundary. Its decrypted logical methods, -targets, headers, bodies, statuses, and streams are dispatched through the same -application routers used by V1. A logical target such as `/v1/chat/completions` -inside a V2 envelope is not a V1 transport request. - -The legacy attestation/session endpoints, outer bearer behavior, encrypted-body -shape, response shape, OAuth behavior, and `SHA-256(user UUID)` Tinfoil cache -namespace remain unchanged for released V1 clients. A new server therefore -continues to serve old clients. New V2 clients speak only V2. Existing V1 user -or platform JWT sessions require fresh V2 authentication rather than token -migration; login, registration, OAuth, and native handoff are valid V2 entry -paths, while existing raw inference-only API keys remain usable. V1 cache -entries do not share the new V2 namespace, and V1 traffic does not gain V2's -credential confidentiality, whole-request binding, or replay guarantees. -This transport change adds no database migration, schema backfill, runtime -environment variable, deployed secret, or additional service. - -## Rollout gates - -Before enabling V2 clients in production: - -1. Deploy the V2-capable backend first and prove released V1 clients still use - their unchanged paths. +## Transport V1 is retired + +Transport V1 was the earlier client transport: `GET /attestation/{nonce}` and +`POST /key_exchange` produced a per-session key, application routes were +served directly, credentials travelled in a plaintext `Authorization` header, +and JSON bodies and SSE events were encrypted one field at a time. The server +no longer implements any of it. + +The listener serves exactly four plaintext surfaces: + +- `GET /health-check`, process liveness; +- `GET /attestation/{nonce}`, the public attestation document described below; +- `POST /v1/remote/relay-access`, the relay fleet's service-credential + admission check; and +- `POST /v2/session` and `POST /v2/request`. + +Every application route is reachable only as a logical target inside a V2 +envelope. A logical target such as `/v1/chat/completions` names an API +version, not a transport. The application router is not mounted on the +listener, and each route independently refuses a request the gateway did not +decrypt: only the gateway can attach the in-process session marker, and +authentication reads only the credential the envelope carried, never an outer +header. + +A released V1 client fails at `POST /key_exchange`, which no longer exists, and +must be updated. V1 access and refresh tokens are accepted nowhere; a V2 client +authenticates afresh through login, registration, OAuth, or native handoff. +Raw inference-only API keys are unaffected and are presented as an `api_key` +credential. + +`GET /attestation/{nonce}` remains as a public attestation document, not as a +handshake. It returns a fresh document carrying the caller's nonce (at most +512 bytes) and no public key, and it establishes no session and stores no +state. The apps' verification page and deployment checks use it to inspect +the enclave's measurements. A client that needs a confidential channel uses +`POST /v2/session`, whose attestation is bound to its handshake transcript. + +## Deployment requirements + +1. Confirm that no supported client still depends on Transport V1 before + deploying a backend without it; such a client cannot be served afterwards + without rolling the backend back. 2. Build and verify the production EIF, publish the reviewed PCR evidence, and confirm each client enforces the intended PCR policy before key derivation. 3. Keep each V2 session's normal traffic on the enclave process that created @@ -752,8 +764,7 @@ Before enabling V2 clients in production: persistence](https://developers.cloudflare.com/load-balancing/additional-options/dns-persistence/) can meet this requirement; HTTP-header affinity does not apply in DNS-only mode. Verify the actual topology and persistence rather than inferring it - from a hostname. For a proxied HTTP deployment whose multiple origins rely - on cookie affinity, preserve the existing cookie policy for V1 and add a + from a hostname. For a proxied HTTP deployment with multiple origins, use a [custom load-balancing rule](https://developers.cloudflare.com/load-balancing/additional-options/load-balancing-rules/) matching `starts_with(http.request.uri.path, "/v2/")` that overrides only @@ -762,9 +773,8 @@ Before enabling V2 clients in production: on `x-opensecret-routing-key`, requires that header, and uses the maximum 3,600-second idle TTL. Canonical clients retire the absolute 3,600-second enclave session 30 seconds early, before an otherwise-idle affinity entry - can expire. Global replacement of cookie affinity would break released V1 - clients, while cookie affinity alone is insufficient for V2 because V2 - deliberately omits credentials and rejects outer cookies. Header affinity + can expire. Cookie affinity is insufficient for V2 because V2 deliberately + omits credentials and rejects outer cookies. Header affinity also cannot use Cloudflare's sticky zero-downtime failover; an origin loss therefore requires a fresh attestation and session. Only the marked outer `400` recovery cases permit one automatic resend; network failure alone @@ -790,9 +800,8 @@ Before enabling V2 clients in production: 8. Load-test concurrent large requests against the production enclave memory profile and set operational admission and headroom accordingly. The protocol intentionally has no custom aggregate memory reservation layer. -9. Retain a coordinated rollback plan. Rolling the backend back below V2 after - publishing V2-only clients strands those clients; they intentionally do not - downgrade or transmit credentials over V1. +9. Retain a coordinated rollback plan. Clients speak only V2 and never + downgrade, so a rollback target must itself serve V2. ## Diagnostics diff --git a/services/opensecret/src/aead_db_tamper_tests.rs b/services/opensecret/src/aead_db_tamper_tests.rs index 955fabdf2..b1e1fb9e3 100644 --- a/services/opensecret/src/aead_db_tamper_tests.rs +++ b/services/opensecret/src/aead_db_tamper_tests.rs @@ -3042,7 +3042,7 @@ mod password_reset_limits { .into_parts(); parts .extensions - .insert(TransportSession::v2(SessionId::from_bytes([0xAB; 16]))); + .insert(TransportSession::new(SessionId::from_bytes([0xAB; 16]))); Request::from_parts(parts, body) } diff --git a/services/opensecret/src/bounded_ttl_cache.rs b/services/opensecret/src/bounded_ttl_cache.rs index f91a18c30..df2265277 100644 --- a/services/opensecret/src/bounded_ttl_cache.rs +++ b/services/opensecret/src/bounded_ttl_cache.rs @@ -3,7 +3,6 @@ use std::collections::hash_map::RandomState; use std::hash::Hash; use std::num::NonZeroUsize; use std::time::{Duration, Instant}; -use zeroize::Zeroize; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum InsertOutcome { @@ -18,19 +17,6 @@ struct TimedEntry { expires_at: Instant, } -/// Values detached from the cache so their destructors and deallocation can -/// run after the caller releases the cache lock. -#[must_use = "keep retired values alive until after releasing the cache lock"] -pub(crate) struct RetiredValues { - entries: Vec>, -} - -impl RetiredValues { - pub(crate) fn removed_count(&self) -> usize { - self.entries.len() - } -} - /// A private, fixed-capacity TTL cache with oldest-first admission. /// /// The wrapped cache uses `RandomState`, preallocates for its immutable capacity, @@ -58,10 +44,6 @@ where /// Inserts a new value, always admitting it. At capacity, an expired oldest /// entry is reclaimed first; otherwise the oldest live entry is evicted. /// Duplicate keys retain the historical latest-request-wins behavior. - pub(crate) fn insert_evicting(&mut self, key: K, value: V) -> InsertOutcome { - self.insert_evicting_at(key, value, Instant::now()) - } - pub(crate) fn insert_evicting_at(&mut self, key: K, value: V, now: Instant) -> InsertOutcome { let expires_at = now .checked_add(self.ttl) @@ -97,9 +79,8 @@ where } /// Returns a live value without consuming it. Reads do not change the - /// recency order, so LRU order keeps matching expiry order as - /// [`Self::retire_expired_at`] requires. An expired entry is removed - /// instead of returned. + /// recency order, so LRU order keeps matching expiry order and eviction + /// stays oldest-first. An expired entry is removed instead of returned. #[cfg(test)] pub(crate) fn get_live(&mut self, key: &K) -> Option<&V> { self.get_live_at(key, Instant::now()) @@ -117,57 +98,6 @@ where self.entries.peek(key).map(|entry| &entry.value) } - /// Removes a value exactly once and returns it only while its TTL is live. - pub(crate) fn take_live(&mut self, key: &K) -> Option { - self.take_live_at(key, Instant::now()) - } - - fn take_live_at(&mut self, key: &K, now: Instant) -> Option { - let entry = self.entries.pop(key)?; - if entry.expires_at <= now { - drop(entry); - None - } else { - Some(entry.value) - } - } - - /// Detaches the oldest expired values without scanning live entries. - /// - /// Insertion and replacement both move a value to MRU with a fresh fixed - /// TTL, so expiry order matches LRU order. Each value is zeroized in place - /// before removal so a Rust move cannot leave secret bytes in CLru's - /// preallocated backing storage. Returning the zeroized values lets the - /// caller release its lock before their destructors and deallocation run. - pub(crate) fn retire_expired_at(&mut self, now: Instant) -> RetiredValues - where - V: Zeroize, - { - let expired_count = self - .entries - .iter() - .rev() - .take_while(|(_, entry)| entry.expires_at <= now) - .count(); - // Allocate once so secret-bearing values are not repeatedly relocated - // as the retirement buffer grows. - let mut entries = Vec::with_capacity(expired_count); - for _ in 0..expired_count { - self.entries - .back_mut() - .expect("counted oldest cache entry must remain present") - .1 - .value - .zeroize(); - let (_, entry) = self - .entries - .pop_back() - .expect("peeked oldest cache entry must remain present"); - entries.push(entry); - } - RetiredValues { entries } - } - #[cfg(test)] pub(crate) fn len(&self) -> usize { self.entries.len() @@ -205,61 +135,31 @@ mod tests { InsertOutcome::EvictedOldest ); assert_eq!(cache.len(), 3); - assert_eq!(cache.take_live_at(&1, start + Duration::from_secs(4)), None); + assert_eq!(cache.get_live_at(&1, start + Duration::from_secs(4)), None); assert_eq!( - cache.take_live_at(&4, start + Duration::from_secs(4)), - Some("four") + cache.get_live_at(&4, start + Duration::from_secs(4)), + Some(&"four") ); } - #[test] - fn configured_pending_capacity_admits_the_next_entry_by_evicting_oldest() { - let start = Instant::now(); - assert_eq!(crate::MAX_PENDING_ATTESTATIONS, 65_536); - assert_eq!(crate::PENDING_ATTESTATION_TTL, Duration::from_secs(5 * 60)); - let capacity = crate::MAX_PENDING_ATTESTATIONS; - let mut cache = cache(capacity, crate::PENDING_ATTESTATION_TTL); - - for key in 0..capacity { - assert_eq!( - cache.insert_evicting_at(key, (), start), - InsertOutcome::Inserted - ); - } - assert_eq!(cache.len(), capacity); - assert_eq!( - cache.insert_evicting_at(capacity, (), start), - InsertOutcome::EvictedOldest - ); - assert_eq!(cache.len(), capacity); - assert_eq!(cache.take_live_at(&0, start), None); - assert_eq!(cache.take_live_at(&capacity, start), Some(())); - } - #[test] fn newest_survives_until_capacity_later_insertions() { let start = Instant::now(); let mut cache = cache(4, Duration::from_secs(300)); - cache.insert_evicting_at(0, 0, start); - for key in 1..4 { + for key in 0..4 { cache.insert_evicting_at(key, key, start); } - assert_eq!(cache.take_live_at(&0, start), Some(0)); - cache.insert_evicting_at(10, 10, start); for key in 11..14 { cache.insert_evicting_at(key, key, start); assert_eq!(cache.len(), 4); } - assert_eq!(cache.take_live_at(&10, start), Some(10)); + assert_eq!(cache.get_live_at(&10, start), Some(&10)); - cache.insert_evicting_at(20, 20, start); - for key in 21..25 { - cache.insert_evicting_at(key, key, start); - } - assert_eq!(cache.take_live_at(&20, start), None); - assert_eq!(cache.take_live_at(&24, start), Some(24)); + cache.insert_evicting_at(14, 14, start); + assert_eq!(cache.get_live_at(&10, start), None); + assert_eq!(cache.get_live_at(&14, start), Some(&14)); } #[test] @@ -276,81 +176,19 @@ mod tests { assert_eq!(cache.len(), 2); cache.insert_evicting_at(3, "three", start + Duration::from_secs(3)); - assert_eq!(cache.take_live_at(&2, start + Duration::from_secs(4)), None); + assert_eq!(cache.get_live_at(&2, start + Duration::from_secs(4)), None); assert_eq!( - cache.take_live_at(&1, start + Duration::from_secs(11)), - Some("new") + cache.get_live_at(&1, start + Duration::from_secs(11)), + Some(&"new") ); } - #[test] - fn arbitrary_take_is_one_use() { - let start = Instant::now(); - let mut cache = cache(3, Duration::from_secs(10)); - cache.insert_evicting_at(1, "one", start); - cache.insert_evicting_at(2, "two", start); - cache.insert_evicting_at(3, "three", start); - - assert_eq!(cache.take_live_at(&2, start), Some("two")); - assert_eq!(cache.take_live_at(&2, start), None); - assert_eq!(cache.len(), 2); - } - #[test] fn exact_ttl_boundary_is_expired() { let start = Instant::now(); let mut cache = cache(2, Duration::from_secs(5)); cache.insert_evicting_at(1, "one", start); - assert_eq!(cache.take_live_at(&1, start + Duration::from_secs(5)), None); - } - - #[test] - fn retires_untouched_expired_values_below_capacity_and_drops_outside_cache() { - let start = Instant::now(); - let zeroizes = Arc::new(AtomicUsize::new(0)); - let drops = Arc::new(AtomicUsize::new(0)); - let mut cache = cache(4, Duration::from_secs(5)); - - let spy = || ZeroizingDropSpy { - zeroizes: zeroizes.clone(), - drops: drops.clone(), - }; - cache.insert_evicting_at(1, spy(), start); - cache.insert_evicting_at(2, spy(), start + Duration::from_secs(4)); - - let retired = cache.retire_expired_at(start + Duration::from_secs(5)); - assert_eq!(retired.removed_count(), 1); - assert_eq!(cache.len(), 1); - assert_eq!(zeroizes.load(Ordering::SeqCst), 1); - assert_eq!(drops.load(Ordering::SeqCst), 0); - - drop(retired); - assert_eq!(drops.load(Ordering::SeqCst), 1); - assert!(cache - .take_live_at(&2, start + Duration::from_secs(5)) - .is_some()); - } - - #[test] - fn expiry_retirement_preserves_survivor_order() { - let start = Instant::now(); - let mut cache = cache(3, Duration::from_secs(5)); - cache.insert_evicting_at(1, 1_u8, start); - cache.insert_evicting_at(2, 2_u8, start + Duration::from_secs(4)); - cache.insert_evicting_at(3, 3_u8, start + Duration::from_secs(4)); - - drop(cache.retire_expired_at(start + Duration::from_secs(5))); - cache.insert_evicting_at(4, 4_u8, start + Duration::from_secs(5)); - assert_eq!( - cache.insert_evicting_at(5, 5_u8, start + Duration::from_secs(5)), - InsertOutcome::EvictedOldest - ); - - assert_eq!(cache.take_live_at(&2, start + Duration::from_secs(5)), None); - assert_eq!( - cache.take_live_at(&3, start + Duration::from_secs(5)), - Some(3) - ); + assert_eq!(cache.get_live_at(&1, start + Duration::from_secs(5)), None); } #[test] @@ -365,12 +203,12 @@ mod tests { InsertOutcome::ReclaimedExpired ); assert_eq!( - cache.take_live_at(&2, start + Duration::from_secs(5)), - Some("live") + cache.get_live_at(&2, start + Duration::from_secs(5)), + Some(&"live") ); assert_eq!( - cache.take_live_at(&3, start + Duration::from_secs(5)), - Some("new") + cache.get_live_at(&3, start + Duration::from_secs(5)), + Some(&"new") ); } @@ -382,23 +220,6 @@ mod tests { } } - struct ZeroizingDropSpy { - zeroizes: Arc, - drops: Arc, - } - - impl Zeroize for ZeroizingDropSpy { - fn zeroize(&mut self) { - self.zeroizes.fetch_add(1, Ordering::SeqCst); - } - } - - impl Drop for ZeroizingDropSpy { - fn drop(&mut self) { - self.drops.fetch_add(1, Ordering::SeqCst); - } - } - #[test] fn removed_values_drop_immediately_for_every_removal_path() { let start = Instant::now(); @@ -414,7 +235,7 @@ mod tests { assert_eq!(drops.load(Ordering::SeqCst), 2, "capacity eviction"); assert!(cache - .take_live_at(&2, start + Duration::from_secs(5)) + .get_live_at(&2, start + Duration::from_secs(5)) .is_none()); assert_eq!(drops.load(Ordering::SeqCst), 3, "expiry"); @@ -430,7 +251,10 @@ mod tests { for key in 0..512 { let cache = cache.clone(); tasks.push(tokio::spawn(async move { - cache.write().await.insert_evicting(key, key); + cache + .write() + .await + .insert_evicting_at(key, key, Instant::now()); })); } @@ -440,49 +264,31 @@ mod tests { assert_eq!(cache.read().await.len(), 32); } - #[tokio::test] - async fn concurrent_take_has_exactly_one_winner() { - let cache = Arc::new(RwLock::new(cache(1, Duration::from_secs(300)))); - cache.write().await.insert_evicting(1, "one-use"); - - let mut tasks = Vec::new(); - for _ in 0..32 { - let cache = cache.clone(); - tasks.push(tokio::spawn( - async move { cache.write().await.take_live(&1) }, - )); - } - - let mut winners = 0; - for task in tasks { - if task.await.unwrap() == Some("one-use") { - winners += 1; - } - } - assert_eq!(winners, 1); - assert_eq!(cache.read().await.len(), 0); - } - #[test] - fn arbitrary_removal_and_extended_churn_remain_fixed_capacity() { + fn expiry_removal_and_extended_churn_remain_fixed_capacity() { let start = Instant::now(); - let mut cache = cache(128, Duration::from_secs(300)); + let ttl = Duration::from_secs(300); + let mut cache = cache(128, ttl); - for key in 0..128 { + // Every third key expires first; reading those leaves holes behind. + for key in (0..128).step_by(3) { cache.insert_evicting_at(key, key, start); } + for key in (0..128).filter(|key| key % 3 != 0) { + cache.insert_evicting_at(key, key, start + Duration::from_secs(100)); + } for key in (0..128).step_by(3) { - assert_eq!(cache.take_live_at(&key, start), Some(key)); + assert_eq!(cache.get_live_at(&key, start + ttl), None); } for key in 128..(128 * 12) { - cache.insert_evicting_at(key, key, start); + cache.insert_evicting_at(key, key, start + ttl); assert!(cache.len() <= 128); } assert_eq!(cache.len(), 128); assert_eq!( - cache.take_live_at(&(128 * 12 - 1), start), - Some(128 * 12 - 1) + cache.get_live_at(&(128 * 12 - 1), start + ttl), + Some(&(128 * 12 - 1)) ); } @@ -506,7 +312,7 @@ mod tests { } #[test] - fn get_live_does_not_reorder_entries_so_oldest_expiry_is_still_retired_first() { + fn get_live_does_not_reorder_entries_so_the_oldest_is_still_evicted_first() { let start = Instant::now(); let mut cache = cache(3, Duration::from_secs(60)); cache.insert_evicting_at(1, 1u8, start); @@ -518,13 +324,15 @@ mod tests { cache.get_live_at(&1, start + Duration::from_secs(30)), Some(&1u8) ); - let retired = cache.retire_expired_at(start + Duration::from_secs(65)); - assert_eq!(retired.removed_count(), 1); - assert_eq!(cache.get_live_at(&1, start + Duration::from_secs(65)), None); assert_eq!( - cache.get_live_at(&2, start + Duration::from_secs(65)), + cache.insert_evicting_at(4, 4u8, start + Duration::from_secs(30)), + InsertOutcome::EvictedOldest + ); + assert_eq!(cache.get_live_at(&1, start + Duration::from_secs(30)), None); + assert_eq!( + cache.get_live_at(&2, start + Duration::from_secs(30)), Some(&2u8) ); - assert_eq!(cache.len(), 2); + assert_eq!(cache.len(), 3); } } diff --git a/services/opensecret/src/encrypt.rs b/services/opensecret/src/encrypt.rs index b78ba7a39..e676f71c7 100644 --- a/services/opensecret/src/encrypt.rs +++ b/services/opensecret/src/encrypt.rs @@ -13,7 +13,6 @@ use secp256k1::SecretKey; use serde::de::DeserializeOwned; use sha2::{Digest, Sha256, Sha512}; use std::{process::Command, sync::Arc}; -use tokio::sync::Mutex; use uuid::Uuid; use crate::aws_credentials::AwsCredentialManager; @@ -592,49 +591,6 @@ pub async fn generate_random_bytes_from_enclave( parse_kmstool_plaintext(&output_str, "genrandom", Some(length)) } -pub struct CustomRng { - buffer: Mutex>, -} - -impl CustomRng { - pub fn new() -> Self { - CustomRng { - buffer: Mutex::new(Vec::new()), - } - } - - async fn fill_buffer(&self) { - let bytes: [u8; 1024] = generate_random(); - let mut buffer = self.buffer.lock().await; - buffer.extend_from_slice(&bytes); - } - - pub async fn fill_bytes(&self, dest: &mut [u8]) { - let mut buffer = self.buffer.lock().await; - while buffer.len() < dest.len() { - drop(buffer); // Release the lock before filling the buffer - self.fill_buffer().await; - buffer = self.buffer.lock().await; - } - - let n = dest.len(); - dest.copy_from_slice(&buffer[..n]); - *buffer = buffer[n..].to_vec(); - } - - pub async fn next_u32(&self) -> u32 { - let mut bytes = [0u8; 4]; - self.fill_bytes(&mut bytes).await; - u32::from_le_bytes(bytes) - } - - pub async fn next_u64(&self) -> u64 { - let mut bytes = [0u8; 8]; - self.fill_bytes(&mut bytes).await; - u64::from_le_bytes(bytes) - } -} - #[cfg(test)] mod tests { use super::*; diff --git a/services/opensecret/src/inference.rs b/services/opensecret/src/inference.rs index 5a2125200..6efd56871 100644 --- a/services/opensecret/src/inference.rs +++ b/services/opensecret/src/inference.rs @@ -320,7 +320,6 @@ impl AttemptFailure { pub(crate) enum CompletionEvidence { NonStreamingResponse, ProviderDone, - FinishSignalThenEof, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/services/opensecret/src/jwt.rs b/services/opensecret/src/jwt.rs index b90f3fc63..b062615c1 100644 --- a/services/opensecret/src/jwt.rs +++ b/services/opensecret/src/jwt.rs @@ -6,7 +6,6 @@ use std::sync::Arc; use axum::{ body::Body, extract::{Request, State}, - http::header, middleware::Next, response::IntoResponse, }; @@ -34,15 +33,13 @@ use crate::{ web::encryption_middleware::TransportSession, }; -pub const USER_ACCESS: &str = "access"; -pub const USER_REFRESH: &str = "refresh"; +// Audiences of the retired pre-V2 session tokens. Nothing issues or accepts +// them; they stay reserved so a third-party token can never carry one. +const RETIRED_SESSION_AUDIENCES: [&str; 4] = + ["access", "refresh", "platform_access", "platform_refresh"]; -pub const PLATFORM_ACCESS: &str = "platform_access"; -pub const PLATFORM_REFRESH: &str = "platform_refresh"; -// Every internal Transport V2 audience intentionally exceeds the existing -// 50-byte third-party audience limit. Reserving these values therefore does -// not newly reject any audience that a V1 caller could issue before Transport -// V2 existed. +// Every internal audience intentionally exceeds the 50-byte third-party +// audience limit, so no third-party token can carry one. pub const TRANSPORT_V2_USER_ACCESS: &str = "urn:opensecret:internal:transport-v2:user:access-token"; pub const TRANSPORT_V2_USER_REFRESH: &str = "urn:opensecret:internal:transport-v2:user:refresh-token"; @@ -62,31 +59,11 @@ pub const USER_TOKEN_FORMAT_V2: u8 = 2; #[derive(Debug, Clone)] pub enum TokenType { - Access, - Refresh, TransportV2Access, TransportV2Refresh, ThirdParty { aud: Option, azp: String }, } -impl TokenType { - pub(crate) const fn access_for_transport(is_transport_v2: bool) -> Self { - if is_transport_v2 { - Self::TransportV2Access - } else { - Self::Access - } - } - - pub(crate) const fn refresh_for_transport(is_transport_v2: bool) -> Self { - if is_transport_v2 { - Self::TransportV2Refresh - } else { - Self::Refresh - } - } -} - #[derive(Clone)] pub struct NewToken { pub token: String, @@ -262,11 +239,7 @@ impl AuthContext { impl TokenType { pub fn validate_third_party_audience(aud: &str) -> Result<(), ApiError> { // Validate third party audience can't use our internal audience types - const RESERVED_AUDIENCES: [&str; 9] = [ - USER_ACCESS, - USER_REFRESH, - PLATFORM_ACCESS, - PLATFORM_REFRESH, + const RESERVED_AUDIENCES: [&str; 5] = [ TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH, TRANSPORT_V2_PLATFORM_ACCESS, @@ -275,7 +248,7 @@ impl TokenType { ]; // 1. Check for reserved audiences - if RESERVED_AUDIENCES.contains(&aud) { + if RESERVED_AUDIENCES.contains(&aud) || RETIRED_SESSION_AUDIENCES.contains(&aud) { tracing::error!( "Third-party tokens cannot use internal audience types: {}", aud @@ -463,10 +436,7 @@ impl NewToken { Duration::hours(1), ) } - TokenType::Access - | TokenType::Refresh - | TokenType::TransportV2Access - | TokenType::TransportV2Refresh => { + TokenType::TransportV2Access | TokenType::TransportV2Refresh => { tracing::error!("User access/refresh tokens require AuthContext"); return Err(ApiError::BadRequest); } @@ -531,14 +501,6 @@ impl NewToken { } let (aud, duration) = match &token_type { - TokenType::Access => ( - Some(USER_ACCESS.to_string()), - Duration::minutes(app_state.config.access_token_maxage), - ), - TokenType::Refresh => ( - Some(USER_REFRESH.to_string()), - Duration::days(app_state.config.refresh_token_maxage), - ), TokenType::TransportV2Access => ( Some(TRANSPORT_V2_USER_ACCESS.to_string()), Duration::minutes(app_state.config.access_token_maxage), @@ -600,16 +562,6 @@ impl NewToken { app_state: &AppState, ) -> Result { let (aud, azp, duration) = match token_type { - TokenType::Access => ( - PLATFORM_ACCESS.to_string(), - None, - Duration::minutes(app_state.config.access_token_maxage), - ), - TokenType::Refresh => ( - PLATFORM_REFRESH.to_string(), - None, - Duration::days(app_state.config.refresh_token_maxage), - ), TokenType::TransportV2Access => ( TRANSPORT_V2_PLATFORM_ACCESS.to_string(), None, @@ -867,39 +819,28 @@ pub async fn generate_jwt_secret( } } +/// The bearer token the Transport V2 gateway decrypted from the request +/// envelope. A request that did not come through the gateway has no transport +/// session and therefore no credential; outer HTTP headers are never read. +fn bearer_credential(req: &Request) -> Option<&str> { + req.extensions().get::()?; + req.extensions() + .get::() + .filter(|credential| credential.kind() == CredentialKind::Bearer) + .map(Credential::value) +} + pub async fn validate_jwt( State(data): State>, mut req: Request, next: Next, ) -> impl IntoResponse { - let is_transport_v2 = req - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - let token = if is_transport_v2 { - match req.extensions().get::() { - Some(credential) if credential.kind() == CredentialKind::Bearer => credential.value(), - _ => return ApiError::InvalidJwt.into_response(), - } - } else { - match req - .headers() - .get(header::AUTHORIZATION) - .and_then(|auth_header| auth_header.to_str().ok()) - .and_then(|auth_value| auth_value.strip_prefix("Bearer ")) - { - Some(token) => token, - None => return ApiError::InvalidJwt.into_response(), - } + let Some(token) = bearer_credential(&req) else { + return ApiError::InvalidJwt.into_response(); }; - let expected_audience = if is_transport_v2 { - TRANSPORT_V2_USER_ACCESS - } else { - USER_ACCESS - }; let (claims, access_token_expired) = - match validate_access_token_for_auth(token, &data, expected_audience) { + match validate_access_token_for_auth(token, &data, TRANSPORT_V2_USER_ACCESS) { Ok(validation) => validation, Err(_) => return ApiError::InvalidJwt.into_response(), }; @@ -952,34 +893,12 @@ pub async fn validate_platform_jwt( mut req: Request, next: Next, ) -> impl IntoResponse { - let is_transport_v2 = req - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - let token = if is_transport_v2 { - match req.extensions().get::() { - Some(credential) if credential.kind() == CredentialKind::Bearer => credential.value(), - _ => return ApiError::InvalidJwt.into_response(), - } - } else { - match req - .headers() - .get(header::AUTHORIZATION) - .and_then(|auth_header| auth_header.to_str().ok()) - .and_then(|auth_value| auth_value.strip_prefix("Bearer ")) - { - Some(token) => token, - None => return ApiError::InvalidJwt.into_response(), - } + let Some(token) = bearer_credential(&req) else { + return ApiError::InvalidJwt.into_response(); }; - let expected_audience = if is_transport_v2 { - TRANSPORT_V2_PLATFORM_ACCESS - } else { - PLATFORM_ACCESS - }; let (claims, access_token_expired) = - match validate_access_token_for_auth(token, &data, expected_audience) { + match validate_access_token_for_auth(token, &data, TRANSPORT_V2_PLATFORM_ACCESS) { Ok(validation) => validation, Err(_) => return ApiError::InvalidJwt.into_response(), }; @@ -1044,7 +963,7 @@ fn validate_token_with_keys( fn is_access_token_audience(audience: &str) -> bool { matches!( audience, - USER_ACCESS | PLATFORM_ACCESS | TRANSPORT_V2_USER_ACCESS | TRANSPORT_V2_PLATFORM_ACCESS + TRANSPORT_V2_USER_ACCESS | TRANSPORT_V2_PLATFORM_ACCESS ) } @@ -1173,21 +1092,24 @@ mod tests { let other_keys = test_keys(2); let expired = Utc::now() - Duration::minutes(1); - let expired_access = signed_test_token(&trusted_keys, USER_ACCESS, Some(expired)); + let expired_access = + signed_test_token(&trusted_keys, TRANSPORT_V2_USER_ACCESS, Some(expired)); assert!(matches!( - validate_token_with_keys(&expired_access, &trusted_keys, USER_ACCESS), + validate_token_with_keys(&expired_access, &trusted_keys, TRANSPORT_V2_USER_ACCESS), Err(ApiError::AccessTokenExpired) )); - let wrong_audience = signed_test_token(&trusted_keys, USER_REFRESH, Some(expired)); + let wrong_audience = + signed_test_token(&trusted_keys, TRANSPORT_V2_USER_REFRESH, Some(expired)); assert!(matches!( - validate_token_with_keys(&wrong_audience, &trusted_keys, USER_ACCESS), + validate_token_with_keys(&wrong_audience, &trusted_keys, TRANSPORT_V2_USER_ACCESS), Err(ApiError::InvalidJwt) )); - let wrong_signature = signed_test_token(&other_keys, USER_ACCESS, Some(expired)); + let wrong_signature = + signed_test_token(&other_keys, TRANSPORT_V2_USER_ACCESS, Some(expired)); assert!(matches!( - validate_token_with_keys(&wrong_signature, &trusted_keys, USER_ACCESS), + validate_token_with_keys(&wrong_signature, &trusted_keys, TRANSPORT_V2_USER_ACCESS), Err(ApiError::InvalidJwt) )); } @@ -1197,27 +1119,23 @@ mod tests { let keys = test_keys(3); let expired = Utc::now() - Duration::minutes(1); - let refresh = signed_test_token(&keys, USER_REFRESH, Some(expired)); + let refresh = signed_test_token(&keys, TRANSPORT_V2_USER_REFRESH, Some(expired)); assert!(matches!( - validate_token_with_keys(&refresh, &keys, USER_REFRESH), + validate_token_with_keys(&refresh, &keys, TRANSPORT_V2_USER_REFRESH), Err(ApiError::InvalidJwt) )); - let platform_access = signed_test_token(&keys, PLATFORM_ACCESS, Some(expired)); + let platform_access = signed_test_token(&keys, TRANSPORT_V2_PLATFORM_ACCESS, Some(expired)); assert!(matches!( - validate_token_with_keys(&platform_access, &keys, PLATFORM_ACCESS), + validate_token_with_keys(&platform_access, &keys, TRANSPORT_V2_PLATFORM_ACCESS), Err(ApiError::AccessTokenExpired) )); } #[test] - fn token_audiences_are_exactly_separated_across_transport_and_principal_kinds() { + fn token_audiences_are_exactly_separated_across_principal_and_token_kinds() { let keys = test_keys(6); let audiences = [ - USER_ACCESS, - USER_REFRESH, - PLATFORM_ACCESS, - PLATFORM_REFRESH, TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH, TRANSPORT_V2_PLATFORM_ACCESS, @@ -1248,11 +1166,40 @@ mod tests { ] { assert!( transport_v2_audience.len() > 50, - "internal V2 audiences must remain outside V1's existing third-party audience space" + "internal audiences must remain outside the third-party audience space" ); } } + #[test] + fn retired_session_audiences_are_reserved_and_never_accepted() { + let keys = test_keys(10); + for retired_audience in RETIRED_SESSION_AUDIENCES { + assert!(TokenType::validate_third_party_audience(retired_audience).is_err()); + assert!(!is_access_token_audience(retired_audience)); + + let token = signed_test_token( + &keys, + retired_audience, + Some(Utc::now() + Duration::minutes(5)), + ); + for accepted_audience in [ + TRANSPORT_V2_USER_ACCESS, + TRANSPORT_V2_USER_REFRESH, + TRANSPORT_V2_PLATFORM_ACCESS, + TRANSPORT_V2_PLATFORM_REFRESH, + ] { + assert!( + matches!( + validate_token_with_keys(&token, &keys, accepted_audience), + Err(ApiError::InvalidJwt) + ), + "a {retired_audience} token was validated as {accepted_audience}" + ); + } + } + } + #[test] fn native_handoff_grant_is_exactly_session_request_and_key_bound() { let trusted_keys = test_keys(7); @@ -1310,7 +1257,7 @@ mod tests { assert!(TokenType::validate_third_party_audience(TRANSPORT_V2_NATIVE_HANDOFF).is_err()); assert!( TRANSPORT_V2_NATIVE_HANDOFF.len() > 50, - "the handoff audience must remain outside V1's existing third-party audience space" + "the handoff audience must remain outside the third-party audience space" ); } @@ -1353,13 +1300,13 @@ mod tests { let malformed_binding = URL_SAFE_NO_PAD.encode([7u8; 31]); let token = signed_test_token_with_auth_binding( &keys, - USER_ACCESS, + TRANSPORT_V2_USER_ACCESS, Some(Utc::now() - Duration::minutes(1)), Some(malformed_binding), ); let (claims, access_token_expired) = - validate_token_with_keys_for_auth(&token, &keys, USER_ACCESS).unwrap(); + validate_token_with_keys_for_auth(&token, &keys, TRANSPORT_V2_USER_ACCESS).unwrap(); assert!(access_token_expired); assert!(matches!( AuthContext::from_claims(&claims), @@ -1370,16 +1317,20 @@ mod tests { #[test] fn valid_access_and_malformed_tokens_do_not_report_expiration() { let keys = test_keys(4); - let valid = signed_test_token(&keys, USER_ACCESS, Some(Utc::now() + Duration::minutes(5))); - let missing_expiration = signed_test_token(&keys, USER_ACCESS, None); + let valid = signed_test_token( + &keys, + TRANSPORT_V2_USER_ACCESS, + Some(Utc::now() + Duration::minutes(5)), + ); + let missing_expiration = signed_test_token(&keys, TRANSPORT_V2_USER_ACCESS, None); - assert!(validate_token_with_keys(&valid, &keys, USER_ACCESS).is_ok()); + assert!(validate_token_with_keys(&valid, &keys, TRANSPORT_V2_USER_ACCESS).is_ok()); assert!(matches!( - validate_token_with_keys(&missing_expiration, &keys, USER_ACCESS), + validate_token_with_keys(&missing_expiration, &keys, TRANSPORT_V2_USER_ACCESS), Err(ApiError::InvalidJwt) )); assert!(matches!( - validate_token_with_keys("not-a-jwt", &keys, USER_ACCESS), + validate_token_with_keys("not-a-jwt", &keys, TRANSPORT_V2_USER_ACCESS), Err(ApiError::InvalidJwt) )); } @@ -1429,7 +1380,7 @@ mod tests { let auth_context = AuthContext::new(AuthMethod::Password, 7, [3u8; 32]); let mut claims = CustomClaims { sub: Uuid::nil().to_string(), - aud: Some(USER_ACCESS.to_string()), + aud: Some(TRANSPORT_V2_USER_ACCESS.to_string()), azp: None, role: None, token_format: None, @@ -1450,8 +1401,8 @@ mod tests { } #[test] - fn auth_context_rejects_legacy_user_access_and_refresh_claim_shapes() { - for audience in [USER_ACCESS, USER_REFRESH] { + fn auth_context_rejects_user_claims_without_an_auth_context() { + for audience in [TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH] { let claims = CustomClaims { sub: Uuid::nil().to_string(), aud: Some(audience.to_string()), @@ -1465,7 +1416,7 @@ mod tests { assert!( AuthContext::from_claims(&claims).is_err(), - "legacy {audience} claims without auth context must be rejected" + "{audience} claims without auth context must be rejected" ); } } @@ -1474,7 +1425,7 @@ mod tests { fn auth_context_rejects_bad_method() { let mut claims = CustomClaims { sub: Uuid::nil().to_string(), - aud: Some(USER_ACCESS.to_string()), + aud: Some(TRANSPORT_V2_USER_ACCESS.to_string()), azp: None, role: None, token_format: None, @@ -1492,7 +1443,7 @@ mod tests { fn auth_context_rejects_wrong_binding_length() { let mut claims = CustomClaims { sub: Uuid::nil().to_string(), - aud: Some(USER_ACCESS.to_string()), + aud: Some(TRANSPORT_V2_USER_ACCESS.to_string()), azp: None, role: None, token_format: None, diff --git a/services/opensecret/src/lease_aware_cache.rs b/services/opensecret/src/lease_aware_cache.rs deleted file mode 100644 index 15e933724..000000000 --- a/services/opensecret/src/lease_aware_cache.rs +++ /dev/null @@ -1,713 +0,0 @@ -use clru::CLruCache; -use std::collections::hash_map::RandomState; -use std::hash::Hash; -use std::num::NonZeroUsize; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::sync::Arc; -use std::time::{Duration, Instant}; - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub(crate) enum InsertOutcome { - Inserted, - ReclaimedExpired, - EvictedLeastRecentlyUsed, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub(crate) enum InsertError { - DuplicateKey, - AllEntriesLeased, -} - -struct LeaseSlot { - value: V, - leases: AtomicUsize, -} - -impl LeaseSlot { - fn new(value: V) -> Self { - Self { - value, - leases: AtomicUsize::new(0), - } - } - - fn is_leased(&self) -> bool { - self.leases.load(Ordering::Acquire) != 0 - } - - fn try_acquire(&self) -> bool { - self.leases - .fetch_update(Ordering::AcqRel, Ordering::Acquire, |leases| { - leases.checked_add(1) - }) - .is_ok() - } -} - -struct CachedValue { - slot: Arc>, - expires_at: Instant, -} - -impl CachedValue { - fn has_external_lease(&self) -> bool { - self.slot.is_leased() || Arc::strong_count(&self.slot) != 1 - } -} - -/// Cache-owned slots detached for destruction after the caller releases the -/// session-cache mutex. -#[must_use = "keep retired values alive until after releasing the cache lock"] -pub(crate) struct RetiredLeaseValues { - slots: Vec>>, -} - -impl RetiredLeaseValues { - pub(crate) fn removed_count(&self) -> usize { - self.slots.len() - } -} - -/// An RAII lease that prevents its cached value from being expired or evicted. -pub(crate) struct CacheLease { - slot: Arc>, -} - -impl CacheLease { - pub(crate) fn value(&self) -> &V { - &self.slot.value - } -} - -impl Drop for CacheLease { - fn drop(&mut self) { - let previous = self.slot.leases.fetch_sub(1, Ordering::AcqRel); - debug_assert!(previous > 0, "cache lease count underflow"); - } -} - -/// A private, fixed-capacity sliding-TTL LRU cache whose in-flight values stay -/// resident until their final request lease is dropped. -/// -/// As with `BoundedTtlCache`, this deliberately exposes neither resizing nor -/// mutable iteration. Values live behind an `Arc`, so LRU reordering moves only -/// the handle rather than secret key bytes. -pub(crate) struct LeaseAwareTtlCache { - entries: CLruCache, RandomState>, - ttl: Duration, -} - -impl LeaseAwareTtlCache -where - K: Clone + Eq + Hash, -{ - pub(crate) fn new(capacity: NonZeroUsize, ttl: Duration) -> Self { - Self { - entries: CLruCache::with_memory(capacity, capacity.get()), - ttl, - } - } - - /// Inserts a value and evicts the least-recently-used unleased value when - /// full. The only capacity rejection is the true-overload case where every - /// resident value is concurrently leased by an in-flight response. - pub(crate) fn insert_evicting( - &mut self, - key: K, - value: V, - ) -> Result { - self.insert_evicting_at(key, value, Instant::now()) - } - - fn insert_evicting_at( - &mut self, - key: K, - value: V, - now: Instant, - ) -> Result { - if self.entries.peek(&key).is_some() { - drop(value); - return Err(InsertError::DuplicateKey); - } - - let expires_at = self.expiry_at(now); - if !self.entries.is_full() { - self.insert_new(key, value, expires_at); - return Ok(InsertOutcome::Inserted); - } - - // Scan from LRU toward MRU without changing recency. In particular, - // merely being pinned must not refresh idle TTL; only authenticated - // success (or an admitted bodyless request) calls `touch`. - let eviction_key = self - .entries - .iter() - .rev() - .find(|(_, entry)| !entry.has_external_lease()) - .map(|(candidate_key, _)| candidate_key.clone()); - let Some(eviction_key) = eviction_key else { - drop(value); - return Err(InsertError::AllEntriesLeased); - }; - - let evicted = self - .entries - .pop(&eviction_key) - .expect("selected unleased entry must remain present"); - debug_assert_eq!(Arc::strong_count(&evicted.slot), 1); - let outcome = if evicted.expires_at <= now { - InsertOutcome::ReclaimedExpired - } else { - InsertOutcome::EvictedLeastRecentlyUsed - }; - drop(evicted); - self.insert_new(key, value, expires_at); - Ok(outcome) - } - - /// Acquires a request-lifetime lease without updating recency or idle TTL. - /// Call `touch` only after successful authenticated use (or immediately for - /// a valid bodyless request). - pub(crate) fn acquire(&mut self, key: &K) -> Option> { - self.acquire_at(key, Instant::now()) - } - - fn acquire_at(&mut self, key: &K, now: Instant) -> Option> { - let expired_and_unleased = { - let entry = self.entries.peek(key)?; - entry.expires_at <= now && !entry.has_external_lease() - }; - if expired_and_unleased { - let expired = self.entries.pop(key); - debug_assert!(expired - .as_ref() - .is_none_or(|entry| Arc::strong_count(&entry.slot) == 1)); - drop(expired); - return None; - } - - let slot = Arc::clone(&self.entries.peek(key)?.slot); - if !slot.try_acquire() { - return None; - } - Some(CacheLease { slot }) - } - - /// Refreshes a value's sliding idle TTL and moves it to the MRU position. - pub(crate) fn touch(&mut self, key: &K) -> bool { - self.touch_at(key, Instant::now()) - } - - fn touch_at(&mut self, key: &K, now: Instant) -> bool { - let expired_and_unleased = match self.entries.peek(key) { - Some(entry) => entry.expires_at <= now && !entry.has_external_lease(), - None => return false, - }; - if expired_and_unleased { - let expired = self.entries.pop(key); - debug_assert!(expired - .as_ref() - .is_none_or(|entry| Arc::strong_count(&entry.slot) == 1)); - drop(expired); - return false; - } - - let expires_at = self.expiry_at(now); - self.entries - .get_mut(key) - .expect("peeked cache entry must remain present") - .expires_at = expires_at; - true - } - - fn expiry_at(&self, now: Instant) -> Instant { - now.checked_add(self.ttl) - .expect("lease-aware cache TTL must fit in Instant") - } - - fn insert_new(&mut self, key: K, value: V, expires_at: Instant) { - let previous = self.entries.put( - key, - CachedValue { - slot: Arc::new(LeaseSlot::new(value)), - expires_at, - }, - ); - debug_assert!(previous.is_none()); - debug_assert!(self.entries.len() <= self.entries.capacity()); - } - - /// Takes one LRU-to-MRU snapshot of expired, currently unleased keys. - /// - /// A fresh deadline always moves an entry to MRU, while acquisition alone - /// changes neither deadline nor recency. Expired entries therefore form an - /// LRU suffix and this scan can stop at the first live entry. The caller can - /// process the snapshot in bounded batches without repeatedly rescanning - /// expired leased entries. - pub(crate) fn expired_unleased_keys_at(&self, now: Instant) -> Vec { - let mut keys = Vec::new(); - for (key, entry) in self.entries.iter().rev() { - if entry.expires_at > now { - break; - } - if !entry.has_external_lease() { - keys.push(key.clone()); - } - } - keys - } - - /// Revalidates and detaches a bounded candidate batch. - /// - /// Revalidation protects a newly inserted value if another operation - /// removed an expired candidate while the mutex was released. Returned - /// slots retain their values so secret destruction occurs outside the - /// mutex. - pub(crate) fn retire_expired_candidates_at( - &mut self, - keys: &[K], - now: Instant, - ) -> RetiredLeaseValues { - let mut slots = Vec::with_capacity(keys.len()); - for key in keys { - let should_retire = self - .entries - .peek(key) - .is_some_and(|entry| entry.expires_at <= now && !entry.has_external_lease()); - if !should_retire { - continue; - } - - let retired = self - .entries - .pop(key) - .expect("revalidated cache entry must remain present"); - debug_assert_eq!(Arc::strong_count(&retired.slot), 1); - slots.push(retired.slot); - } - RetiredLeaseValues { slots } - } - - #[cfg(test)] - fn len(&self) -> usize { - self.entries.len() - } - - #[cfg(test)] - fn lease_count(&self, key: &K) -> Option { - self.entries - .peek(key) - .map(|entry| entry.slot.leases.load(Ordering::Acquire)) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::web::attestation_routes::SessionState; - use std::sync::atomic::{AtomicUsize, Ordering}; - - fn cache(capacity: usize, ttl: Duration) -> LeaseAwareTtlCache - where - K: Clone + Eq + Hash, - { - LeaseAwareTtlCache::new(NonZeroUsize::new(capacity).unwrap(), ttl) - } - - #[test] - fn configured_policy_and_layout_fit_the_aggregate_budget() { - assert_eq!(crate::MAX_ENCRYPTION_SESSIONS, 2_097_152); - assert_eq!( - crate::ENCRYPTION_SESSION_IDLE_TTL, - Duration::from_secs(65 * 60) - ); - - let accounted_bytes_per_entry = 192; - let accounted_bytes = (crate::MAX_PENDING_ATTESTATIONS + crate::MAX_ENCRYPTION_SESSIONS) - * accounted_bytes_per_entry; - assert!(accounted_bytes <= 500 * 1024 * 1024); - assert_eq!(500 * 1024 * 1024 - accounted_bytes, 109_051_904); - - #[cfg(target_pointer_width = "64")] - { - assert_eq!(std::mem::size_of::(), 32); - assert_eq!(std::mem::size_of::>(), 40); - assert_eq!(std::mem::size_of::>(), 24); - assert_eq!(std::mem::size_of::>(), 8); - - // Cleanup can temporarily hold a UUID candidate snapshot while the - // fixed CLru backing allocation stays reserved. Budget for twice - // the final Vec payload to cover geometric growth/reallocation, - // plus one detached batch of Arc handles. - assert_eq!(std::mem::size_of::(), 16); - let cleanup_snapshot_peak = - crate::MAX_ENCRYPTION_SESSIONS * std::mem::size_of::() * 2; - let detached_batch = crate::secret_cache_maintenance::SESSION_RETIREMENT_BATCH_SIZE - * std::mem::size_of::>>(); - let peak_accounted_bytes = accounted_bytes + cleanup_snapshot_peak + detached_batch; - assert!(peak_accounted_bytes <= 500 * 1024 * 1024); - assert_eq!(500 * 1024 * 1024 - peak_accounted_bytes, 41_910_272); - } - } - - #[test] - fn evicts_lru_and_always_admits_when_an_unleased_entry_exists() { - let start = Instant::now(); - let mut cache = cache(2, Duration::from_secs(60)); - cache.insert_evicting_at(1, "one", start).unwrap(); - cache - .insert_evicting_at(2, "two", start + Duration::from_secs(1)) - .unwrap(); - - assert_eq!( - cache.insert_evicting_at(3, "three", start + Duration::from_secs(2)), - Ok(InsertOutcome::EvictedLeastRecentlyUsed) - ); - assert!(cache - .acquire_at(&1, start + Duration::from_secs(3)) - .is_none()); - assert_eq!( - cache - .acquire_at(&3, start + Duration::from_secs(3)) - .unwrap() - .value(), - &"three" - ); - assert_eq!(cache.len(), 2); - } - - #[test] - fn acquire_without_successful_touch_does_not_change_lru_order() { - let start = Instant::now(); - let mut cache = cache(2, Duration::from_secs(60)); - cache.insert_evicting_at(1, "one", start).unwrap(); - cache - .insert_evicting_at(2, "two", start + Duration::from_secs(1)) - .unwrap(); - - drop( - cache - .acquire_at(&1, start + Duration::from_secs(2)) - .unwrap(), - ); - cache - .insert_evicting_at(3, "three", start + Duration::from_secs(3)) - .unwrap(); - assert!(cache - .acquire_at(&1, start + Duration::from_secs(4)) - .is_none()); - assert!(cache - .acquire_at(&2, start + Duration::from_secs(4)) - .is_some()); - } - - #[test] - fn successful_touch_refreshes_ttl_and_promotes_to_mru() { - let start = Instant::now(); - let mut cache = cache(2, Duration::from_secs(10)); - cache.insert_evicting_at(1, "one", start).unwrap(); - cache - .insert_evicting_at(2, "two", start + Duration::from_secs(1)) - .unwrap(); - - let lease = cache - .acquire_at(&1, start + Duration::from_secs(2)) - .unwrap(); - assert!(cache.touch_at(&1, start + Duration::from_secs(2))); - drop(lease); - cache - .insert_evicting_at(3, "three", start + Duration::from_secs(3)) - .unwrap(); - - assert!(cache - .acquire_at(&2, start + Duration::from_secs(4)) - .is_none()); - assert!(cache - .acquire_at(&1, start + Duration::from_secs(11)) - .is_some()); - } - - #[test] - fn exact_idle_ttl_boundary_is_expired_when_unleased() { - let start = Instant::now(); - let mut cache = cache(1, Duration::from_secs(5)); - cache.insert_evicting_at(1, "one", start).unwrap(); - assert!(cache - .acquire_at(&1, start + Duration::from_secs(5)) - .is_none()); - assert_eq!(cache.len(), 0); - } - - #[test] - fn retires_untouched_expired_values_below_capacity_and_drops_outside_cache() { - struct DropSpy(Arc); - impl Drop for DropSpy { - fn drop(&mut self) { - self.0.fetch_add(1, Ordering::SeqCst); - } - } - - let start = Instant::now(); - let drops = Arc::new(AtomicUsize::new(0)); - let mut cache = cache(4, Duration::from_secs(5)); - cache - .insert_evicting_at(1, DropSpy(drops.clone()), start) - .unwrap(); - cache - .insert_evicting_at(2, DropSpy(drops.clone()), start + Duration::from_secs(4)) - .unwrap(); - - let candidates = cache.expired_unleased_keys_at(start + Duration::from_secs(5)); - assert_eq!(candidates, vec![1]); - let retired = - cache.retire_expired_candidates_at(&candidates, start + Duration::from_secs(5)); - assert_eq!(retired.removed_count(), 1); - assert_eq!(cache.len(), 1); - assert_eq!(drops.load(Ordering::SeqCst), 0); - - drop(retired); - assert_eq!(drops.load(Ordering::SeqCst), 1); - assert!(cache - .acquire_at(&2, start + Duration::from_secs(5)) - .is_some()); - } - - #[test] - fn touched_value_survives_its_original_expiry_snapshot() { - let start = Instant::now(); - let mut cache = cache(2, Duration::from_secs(5)); - cache.insert_evicting_at(1, "one", start).unwrap(); - assert!(cache.touch_at(&1, start + Duration::from_secs(4))); - - assert!(cache - .expired_unleased_keys_at(start + Duration::from_secs(5)) - .is_empty()); - assert_eq!( - cache.expired_unleased_keys_at(start + Duration::from_secs(9)), - vec![1] - ); - } - - #[test] - fn leased_expired_value_waits_for_a_later_cleanup_pass() { - struct DropSpy(Arc); - impl Drop for DropSpy { - fn drop(&mut self) { - self.0.fetch_add(1, Ordering::SeqCst); - } - } - - let start = Instant::now(); - let drops = Arc::new(AtomicUsize::new(0)); - let mut cache = cache(2, Duration::from_secs(5)); - cache - .insert_evicting_at(1, DropSpy(drops.clone()), start) - .unwrap(); - let lease = cache.acquire_at(&1, start).unwrap(); - - let expired_at = start + Duration::from_secs(5); - assert!(cache.expired_unleased_keys_at(expired_at).is_empty()); - assert_eq!(cache.len(), 1); - drop(lease); - - let candidates = cache.expired_unleased_keys_at(expired_at); - let retired = cache.retire_expired_candidates_at(&candidates, expired_at); - assert_eq!(retired.removed_count(), 1); - assert_eq!(drops.load(Ordering::SeqCst), 0); - drop(retired); - assert_eq!(drops.load(Ordering::SeqCst), 1); - } - - #[test] - fn cleanup_skips_leased_expiry_holes_and_preserves_survivor_order() { - let start = Instant::now(); - let mut cache = cache(4, Duration::from_secs(5)); - cache.insert_evicting_at(1, "leased", start).unwrap(); - cache - .insert_evicting_at(2, "expired", start + Duration::from_secs(1)) - .unwrap(); - cache - .insert_evicting_at(3, "live", start + Duration::from_secs(2)) - .unwrap(); - let lease = cache - .acquire_at(&1, start + Duration::from_secs(2)) - .unwrap(); - - let cutoff = start + Duration::from_secs(6); - let candidates = cache.expired_unleased_keys_at(cutoff); - assert_eq!(candidates, vec![2]); - drop(cache.retire_expired_candidates_at(&candidates, cutoff)); - - cache.insert_evicting_at(4, "new", cutoff).unwrap(); - cache.insert_evicting_at(5, "newest", cutoff).unwrap(); - assert_eq!( - cache.insert_evicting_at(6, "overflow", cutoff), - Ok(InsertOutcome::EvictedLeastRecentlyUsed) - ); - assert!(cache.acquire_at(&3, cutoff).is_none()); - assert_eq!(lease.value(), &"leased"); - drop(lease); - } - - #[test] - fn stale_cleanup_candidate_cannot_remove_a_replacement() { - let start = Instant::now(); - let cutoff = start + Duration::from_secs(5); - let mut cache = cache(1, Duration::from_secs(5)); - cache.insert_evicting_at(1, "old", start).unwrap(); - let candidates = cache.expired_unleased_keys_at(cutoff); - - assert!(cache.acquire_at(&1, cutoff).is_none()); - cache.insert_evicting_at(1, "replacement", cutoff).unwrap(); - let retired = cache.retire_expired_candidates_at(&candidates, cutoff); - assert_eq!(retired.removed_count(), 0); - assert_eq!( - cache.acquire_at(&1, cutoff).unwrap().value(), - &"replacement" - ); - } - - #[test] - fn lingering_arc_excludes_expired_value_from_cleanup_snapshot() { - let start = Instant::now(); - let cutoff = start + Duration::from_secs(5); - let mut cache = cache(1, Duration::from_secs(5)); - cache.insert_evicting_at(1, "one", start).unwrap(); - let lingering_arc = Arc::clone(&cache.entries.peek(&1).unwrap().slot); - - assert!(cache.expired_unleased_keys_at(cutoff).is_empty()); - drop(lingering_arc); - assert_eq!(cache.expired_unleased_keys_at(cutoff), vec![1]); - } - - #[test] - fn pinned_lru_is_preserved_and_next_unleased_entry_is_evicted() { - let start = Instant::now(); - let mut cache = cache(2, Duration::from_secs(60)); - cache.insert_evicting_at(1, "one", start).unwrap(); - cache - .insert_evicting_at(2, "two", start + Duration::from_secs(1)) - .unwrap(); - let lease = cache - .acquire_at(&1, start + Duration::from_secs(2)) - .unwrap(); - - assert_eq!( - cache.insert_evicting_at(3, "three", start + Duration::from_secs(3)), - Ok(InsertOutcome::EvictedLeastRecentlyUsed) - ); - assert!(cache - .acquire_at(&1, start + Duration::from_secs(4)) - .is_some()); - assert!(cache - .acquire_at(&2, start + Duration::from_secs(4)) - .is_none()); - drop(lease); - } - - #[test] - fn all_pinned_is_bounded_true_overload_and_drops_rejected_value() { - struct DropSpy(Arc); - impl Drop for DropSpy { - fn drop(&mut self) { - self.0.fetch_add(1, Ordering::SeqCst); - } - } - - let start = Instant::now(); - let drops = Arc::new(AtomicUsize::new(0)); - let mut cache = cache(2, Duration::from_secs(60)); - cache - .insert_evicting_at(1, DropSpy(drops.clone()), start) - .unwrap(); - cache - .insert_evicting_at(2, DropSpy(drops.clone()), start) - .unwrap(); - let first = cache.acquire_at(&1, start).unwrap(); - let second = cache.acquire_at(&2, start).unwrap(); - - assert_eq!( - cache.insert_evicting_at(3, DropSpy(drops.clone()), start), - Err(InsertError::AllEntriesLeased) - ); - assert_eq!(cache.len(), 2); - assert_eq!(drops.load(Ordering::SeqCst), 1); - - drop(first); - assert!(cache - .insert_evicting_at(3, DropSpy(drops.clone()), start) - .is_ok()); - assert_eq!(cache.len(), 2); - assert_eq!(drops.load(Ordering::SeqCst), 2); - drop(second); - } - - #[test] - fn expired_pinned_entry_survives_until_final_lease_drops() { - let start = Instant::now(); - let mut cache = cache(1, Duration::from_secs(5)); - cache.insert_evicting_at(1, "one", start).unwrap(); - let first = cache.acquire_at(&1, start).unwrap(); - - let second = cache - .acquire_at(&1, start + Duration::from_secs(6)) - .expect("an in-flight session remains usable"); - assert_eq!(cache.lease_count(&1), Some(2)); - assert_eq!( - cache.insert_evicting_at(2, "two", start + Duration::from_secs(6)), - Err(InsertError::AllEntriesLeased) - ); - - drop(first); - drop(second); - assert!(!cache.touch_at(&1, start + Duration::from_secs(12))); - assert_eq!(cache.len(), 0); - } - - #[test] - fn lease_drop_decrements_exactly_once() { - let start = Instant::now(); - let mut cache = cache(1, Duration::from_secs(60)); - cache.insert_evicting_at(1, "one", start).unwrap(); - let lease = cache.acquire_at(&1, start).unwrap(); - assert_eq!(cache.lease_count(&1), Some(1)); - drop(lease); - assert_eq!(cache.lease_count(&1), Some(0)); - } - - #[test] - fn final_drop_gap_cannot_detach_a_still_referenced_value() { - let start = Instant::now(); - let mut cache = cache(1, Duration::from_secs(60)); - cache.insert_evicting_at(1, "one", start).unwrap(); - - // Models the narrow interval after CacheLease::drop decrements the - // explicit count but before Rust drops that lease's Arc field. - let lingering_arc = Arc::clone(&cache.entries.peek(&1).unwrap().slot); - assert_eq!(cache.lease_count(&1), Some(0)); - assert_eq!(Arc::strong_count(&lingering_arc), 2); - assert_eq!( - cache.insert_evicting_at(2, "two", start), - Err(InsertError::AllEntriesLeased) - ); - assert_eq!(lingering_arc.value, "one"); - - drop(lingering_arc); - assert!(cache.insert_evicting_at(2, "two", start).is_ok()); - } - - #[test] - fn duplicate_key_never_replaces_a_live_or_leased_session() { - let start = Instant::now(); - let mut cache = cache(1, Duration::from_secs(60)); - cache.insert_evicting_at(1, "original", start).unwrap(); - let lease = cache.acquire_at(&1, start).unwrap(); - - assert_eq!( - cache.insert_evicting_at(1, "replacement", start), - Err(InsertError::DuplicateKey) - ); - assert_eq!(lease.value(), &"original"); - } -} diff --git a/services/opensecret/src/main.rs b/services/opensecret/src/main.rs index 5a289bd4c..2cc030780 100644 --- a/services/opensecret/src/main.rs +++ b/services/opensecret/src/main.rs @@ -7,8 +7,7 @@ use crate::email::{ use crate::encrypt::encrypt_key_deterministic; use crate::encrypt::generate_random; use crate::encrypt::{ - decrypt_with_key, decrypt_with_kms, encrypt_with_key, validate_aes_256_key_length, CustomRng, - GenKeyResult, + decrypt_with_key, decrypt_with_kms, encrypt_with_key, validate_aes_256_key_length, GenKeyResult, }; use crate::jwt::validate_platform_jwt; use crate::login_routes::RegisterCredentials; @@ -22,14 +21,12 @@ use crate::sqs::SqsEventPublisher; use crate::web::dev_spend_gate::require_internal; use crate::web::openai_auth::{validate_openai_auth, validate_optional_openai_auth}; use crate::web::platform_login_routes; +use crate::web::platform_routes; use crate::web::{ conversation_projects_routes, conversations_routes, health_routes, instructions_routes, login_routes, native_handoff_routes, oauth_routes, openai_models_routes, openai_routes, protected_routes, recovery_router, responses_routes, system_one_routes, web_routes, }; -use crate::{attestation_routes::SessionState, web::platform_routes}; -use bounded_ttl_cache::BoundedTtlCache; -use lease_aware_cache::{CacheLease, InsertError as SessionInsertError, LeaseAwareTtlCache}; use crate::jwt::{AuthContext, AuthMethod}; use crate::models::user_seed_wrappings::{NewUserSeedWrapping, UserSeedWrappingError}; @@ -66,12 +63,8 @@ use axum::{ }; use base64::engine::general_purpose; use base64::Engine as _; -use chacha20poly1305::aead::Aead; -use chacha20poly1305::KeyInit; -use chacha20poly1305::{ChaCha20Poly1305, Key, Nonce}; use diesel::Connection; use password_auth::{generate_hash, verify_password, VerifyError}; -use rand_core::{CryptoRng, RngCore}; use secp256k1::SecretKey; use serde::{Deserialize, Serialize}; use serde_json::Value; @@ -80,7 +73,6 @@ use std::collections::HashSet; use std::env; use std::fmt; use std::io::Write; -use std::num::NonZeroUsize; use std::str::FromStr; use std::sync::{Arc, Mutex as StdMutex}; use std::time::Duration; @@ -94,7 +86,6 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilte use uuid::Uuid; use vsock::{VsockAddr, VsockStream}; use web::attestation_routes; -use x25519_dalek::{EphemeralSecret, PublicKey}; mod apple_signin; mod aws_credentials; @@ -111,7 +102,6 @@ mod inference; mod inference_planning; mod jwt; mod kagi; -mod lease_aware_cache; mod log_redaction; mod maple_inference; mod message_signing; @@ -131,7 +121,6 @@ mod provider_routing; mod proxy_config; mod recovery_code; mod remote_enrollment; -mod secret_cache_maintenance; #[cfg(test)] mod security_invariants; mod seed_wrapping; @@ -173,11 +162,6 @@ const KAGI_API_KEY_NAME: &str = "kagi_api_key"; const OS_FLAGS_API_KEY_NAME: &str = "os_flags_api_key"; const OS_FLAGS_BASE_URL_NAME: &str = "os_flags_base_url"; const BILLING_ACCESS_TIMEOUT_SECS: u64 = 5; -const MAX_ATTESTATION_NONCE_BYTES: usize = 512; -const MAX_PENDING_ATTESTATIONS: usize = 65_536; -const PENDING_ATTESTATION_TTL: Duration = Duration::from_secs(5 * 60); -const MAX_ENCRYPTION_SESSIONS: usize = 2_097_152; -const ENCRYPTION_SESSION_IDLE_TTL: Duration = Duration::from_secs(65 * 60); pub(crate) const ERROR_CONTRACT_HEADER: &str = "x-opensecret-error-contract"; pub(crate) const ERROR_CODE_HEADER: &str = "x-opensecret-error-code"; @@ -189,54 +173,6 @@ const IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE: &str = "image_description_unavai pub(crate) const INFERENCE_CAPACITY_ERROR_CODE: &str = "inference_capacity"; const CLIENT_REPLAY_SAFE: &str = "safe"; -type PendingAttestationKey = [u8; 32]; -pub(crate) type SessionLease = CacheLease; - -fn validate_attestation_nonce(nonce: &str) -> Result<(), ApiError> { - if nonce.len() > MAX_ATTESTATION_NONCE_BYTES { - return Err(ApiError::BadRequest); - } - Ok(()) -} - -fn attestation_nonce_key(nonce: &str) -> PendingAttestationKey { - Sha256::digest(nonce.as_bytes()).into() -} - -#[cfg(test)] -mod pending_attestation_key_tests { - use super::*; - - #[test] - fn nonce_limit_is_measured_in_bytes() { - assert!(validate_attestation_nonce(&"a".repeat(512)).is_ok()); - assert!(matches!( - validate_attestation_nonce(&"a".repeat(513)), - Err(ApiError::BadRequest) - )); - - assert!(validate_attestation_nonce(&"é".repeat(256)).is_ok()); - assert!(matches!( - validate_attestation_nonce(&"é".repeat(257)), - Err(ApiError::BadRequest) - )); - } - - #[test] - fn cache_key_is_a_fixed_sha256_digest() { - let first_nonce = Uuid::new_v4().to_string(); - let different_nonce = Uuid::new_v4().to_string(); - let first = attestation_nonce_key(&first_nonce); - - assert_eq!(first, attestation_nonce_key(&first_nonce)); - assert_ne!(first, attestation_nonce_key(&different_nonce)); - assert_eq!(std::mem::size_of_val(&first), 32); - - let expected: PendingAttestationKey = Sha256::digest(first_nonce.as_bytes()).into(); - assert_eq!(first, expected); - } -} - #[derive(Debug, Clone, Deserialize, Serialize)] pub struct EnclaveRequest { pub request_type: String, @@ -435,9 +371,6 @@ pub enum ApiError { #[error("Bad Request")] BadRequest, - #[error("Bad Request")] - SessionNotFound, - #[error("Conflict")] Conflict, @@ -547,7 +480,6 @@ impl IntoResponse for ApiError { ApiError::BadRequest => StatusCode::BAD_REQUEST, ApiError::PasswordTooShort => StatusCode::BAD_REQUEST, ApiError::PasswordTooLong => StatusCode::BAD_REQUEST, - ApiError::SessionNotFound => StatusCode::BAD_REQUEST, ApiError::Conflict => StatusCode::CONFLICT, ApiError::InvalidInviteCode => StatusCode::UNAUTHORIZED, ApiError::RefreshFailed => StatusCode::UNAUTHORIZED, @@ -596,7 +528,6 @@ impl IntoResponse for ApiError { _ => (None, None), }; let error_code = match &self { - ApiError::SessionNotFound => Some(SESSION_NOT_FOUND_ERROR_CODE), ApiError::BillingCleanupUnavailable => Some("billing_account_deletion_failed"), ApiError::AccessTokenExpired => Some(ACCESS_TOKEN_EXPIRED_ERROR_CODE), ApiError::ImageDescriptionUnavailable => Some(IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE), @@ -836,17 +767,6 @@ mod api_error_contract_tests { .await; } - #[tokio::test] - async fn session_not_found_adds_code_without_changing_legacy_response() { - assert_error_response( - ApiError::SessionNotFound, - StatusCode::BAD_REQUEST, - br#"{"status":400,"message":"Bad Request"}"#, - Some(SESSION_NOT_FOUND_ERROR_CODE), - ) - .await; - } - #[tokio::test] async fn access_token_expired_adds_code_without_changing_legacy_response() { assert_error_response( @@ -1103,8 +1023,6 @@ pub struct AppState { provider_router: Arc, rate_limits: web::rate_limit::RateLimits, resend_api_key: Option, - ephemeral_keys: Arc>>, - session_states: Arc>>, oauth_manager: Arc, sqs_publisher: Option>, billing_client: Option, @@ -1566,16 +1484,6 @@ impl AppStateBuilder { provider_router, rate_limits: self.rate_limits, resend_api_key: self.resend_api_key, - ephemeral_keys: Arc::new(RwLock::new(BoundedTtlCache::new( - NonZeroUsize::new(MAX_PENDING_ATTESTATIONS) - .expect("pending attestation capacity must be non-zero"), - PENDING_ATTESTATION_TTL, - ))), - session_states: Arc::new(tokio::sync::Mutex::new(LeaseAwareTtlCache::new( - NonZeroUsize::new(MAX_ENCRYPTION_SESSIONS) - .expect("encryption session capacity must be non-zero"), - ENCRYPTION_SESSION_IDLE_TTL, - ))), oauth_manager, sqs_publisher, billing_client, @@ -2220,143 +2128,6 @@ impl AppState { self.enclave_key.clone() } - pub async fn create_ephemeral_key(&self, nonce: &str) -> Result { - validate_attestation_nonce(nonce)?; - let custom_rng = CustomRng::new(); - - // Use a wrapper that implements RngCore and CryptoRng - let mut rng_wrapper = AsyncRngWrapper::new(custom_rng); - - // Create the EphemeralSecret using the RngCore implementation - let ephemeral_secret = EphemeralSecret::random_from_rng(&mut rng_wrapper); - let public_key = PublicKey::from(&ephemeral_secret); - - self.ephemeral_keys - .write() - .await - .insert_evicting(attestation_nonce_key(nonce), ephemeral_secret); - - Ok(public_key) - } - - pub async fn get_and_remove_ephemeral_secret( - &self, - nonce: &str, - ) -> Result, ApiError> { - validate_attestation_nonce(nonce)?; - Ok(self - .ephemeral_keys - .write() - .await - .take_live(&attestation_nonce_key(nonce))) - } - - pub(crate) async fn store_session_state( - &self, - session_id: Uuid, - session_state: SessionState, - ) -> Result<(), ApiError> { - match self - .session_states - .lock() - .await - .insert_evicting(session_id, session_state) - { - Ok(_) => Ok(()), - Err(SessionInsertError::DuplicateKey) => Err(ApiError::InternalServerError), - Err(SessionInsertError::AllEntriesLeased) => Err(ApiError::TooManyRequests), - } - } - - pub(crate) async fn acquire_request_session( - &self, - session_id: &Uuid, - ) -> Result { - self.session_states - .lock() - .await - .acquire(session_id) - .ok_or(ApiError::SessionNotFound) - } - - pub(crate) async fn touch_session(&self, session_id: &Uuid) -> Result<(), ApiError> { - if self.session_states.lock().await.touch(session_id) { - Ok(()) - } else { - Err(ApiError::BadRequest) - } - } - - pub(crate) async fn decrypt_session_data( - &self, - session_id: &Uuid, - session_lease: &SessionLease, - encrypted_data: &str, - ) -> Result, ApiError> { - let decoded_data = general_purpose::STANDARD - .decode(encrypted_data) - .map_err(|e| { - tracing::error!("Failed to decode base64 data: {:?}", e); - ApiError::BadRequest - })?; - - if decoded_data.len() < 12 { - tracing::error!("Decoded data is too short"); - return Err(ApiError::BadRequest); - } - - let (nonce, ciphertext) = decoded_data.split_at(12); - let nonce_array: [u8; 12] = nonce.try_into().map_err(|e| { - tracing::error!("Failed to convert nonce: {:?}", e); - ApiError::BadRequest - })?; - - let decrypted = session_lease - .value() - .decrypt(ciphertext, &nonce_array) - .map_err(|e| { - tracing::error!("Decryption failed: {:?}", e); - e - })?; - - // Invalid ciphertext must not extend an attacker's retained session. - self.touch_session(session_id).await?; - Ok(decrypted) - } - - pub async fn encrypt_session_data( - &self, - session_id: &Uuid, - data: &[u8], - ) -> Result, ApiError> { - let session_lease = self - .session_states - .lock() - .await - .acquire(session_id) - .ok_or(ApiError::BadRequest)?; - - let session_key = session_lease.value().get_session_key(); - let key = Key::from_slice(session_key.as_ref()); - - let nonce_bytes: [u8; 12] = crate::encrypt::generate_random(); - let nonce = Nonce::from_slice(&nonce_bytes); - - let cipher = ChaCha20Poly1305::new(key); - - let mut encrypted_data = nonce_bytes.to_vec(); - encrypted_data.extend_from_slice( - &cipher - .encrypt(nonce, data) - .map_err(|_| ApiError::InternalServerError)?, - ); - - if !self.session_states.lock().await.touch(session_id) { - return Err(ApiError::BadRequest); - } - Ok(encrypted_data) - } - async fn create_password_reset_request( &self, email: String, @@ -3799,38 +3570,6 @@ async fn retrieve_google_client_id( } } -struct AsyncRngWrapper { - inner: CustomRng, -} - -impl AsyncRngWrapper { - fn new(inner: CustomRng) -> Self { - AsyncRngWrapper { inner } - } -} - -impl RngCore for AsyncRngWrapper { - fn next_u32(&mut self) -> u32 { - futures::executor::block_on(self.inner.next_u32()) - } - - fn next_u64(&mut self) -> u64 { - futures::executor::block_on(self.inner.next_u64()) - } - - fn fill_bytes(&mut self, dest: &mut [u8]) { - futures::executor::block_on(self.inner.fill_bytes(dest)) - } - - fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> { - futures::executor::block_on(self.inner.fill_bytes(dest)); - Ok(()) - } -} - -// Implement CryptoRng for AsyncRngWrapper -impl CryptoRng for AsyncRngWrapper {} - pub fn generate_reset_hash(password: String) -> String { let mut hasher = Sha256::new(); hasher.update(password.as_bytes()); @@ -4035,6 +3774,9 @@ async fn retrieve_kagi_api_key( } } +/// The application routers. They are reachable only inside a Transport V2 +/// envelope: every route parses a body the gateway already decrypted and +/// authenticates with the credential the envelope carried. fn application_routes(app_state: Arc) -> Router<()> { protected_routes(app_state.clone()) .merge( @@ -4043,7 +3785,6 @@ fn application_routes(app_state: Arc) -> Router<()> { ) .route_layer(from_fn_with_state(app_state.clone(), validate_jwt)) .merge(recovery_router(app_state.clone())) - .merge(web::remote::relay::router(app_state.clone())) .merge(login_routes(app_state.clone())) .merge( openai_routes(app_state.clone()) @@ -4091,6 +3832,27 @@ fn application_routes(app_state: Arc) -> Router<()> { ) } +/// Everything a client reaches through the Transport V2 gateway. +fn transport_v2_application(app_state: Arc) -> Router<()> { + application_routes(app_state.clone()) + .merge(health_routes()) + .merge(native_handoff_routes(app_state)) + .layer(from_fn(add_error_contract_header)) +} + +/// The listener's plaintext surface: liveness, the public attestation +/// document, the relay fleet's service-credential admission check, and the +/// Transport V2 endpoints. Application routes are deliberately absent. +fn public_routes( + app_state: Arc, + transport_v2_gateway: &transport_v2::gateway::TransportV2Gateway, +) -> Router<()> { + health_routes() + .merge(attestation_routes::router(app_state.clone())) + .merge(web::remote::relay::router(app_state)) + .merge(transport_v2_gateway.router()) +} + #[tokio::main] async fn main() -> Result<(), Error> { dotenv::dotenv().ok(); @@ -4455,19 +4217,12 @@ async fn main() -> Result<(), Error> { // allow requests from any origin .allow_origin(Any); - let application = application_routes(app_state.clone()); - let v2_application = application - .clone() - .merge(health_routes()) - .merge(native_handoff_routes(app_state.clone())) - .layer(from_fn(add_error_contract_header)); - let transport_v2_gateway = - transport_v2::gateway::TransportV2Gateway::new(app_state.clone(), v2_application); + let transport_v2_gateway = transport_v2::gateway::TransportV2Gateway::new( + app_state.clone(), + transport_v2_application(app_state.clone()), + ); - let app = application - .merge(health_routes()) - .merge(attestation_routes::router(app_state.clone())) - .merge(transport_v2_gateway.router()) + let app = public_routes(app_state.clone(), &transport_v2_gateway) .layer(cors) .layer(from_fn(add_error_contract_header)); @@ -4479,9 +4234,6 @@ async fn main() -> Result<(), Error> { tokio::select! { result = axum::serve(listener, app.into_make_service()) => Ok(result?), - _ = secret_cache_maintenance::run(app_state) => { - unreachable!("secret cache maintenance runs until the server stops") - } _ = transport_v2_gateway.run_maintenance() => { unreachable!("transport-v2 session maintenance runs until the server stops") } diff --git a/services/opensecret/src/oauth.rs b/services/opensecret/src/oauth.rs index 2a5a3faf4..fdb86f155 100644 --- a/services/opensecret/src/oauth.rs +++ b/services/opensecret/src/oauth.rs @@ -60,33 +60,25 @@ struct OAuthStateStoreInner { entries: HashMap, } +/// One pending OAuth authorization round trip. +/// +/// The one-time callback state is bound to the attested transport session +/// that initiated the redirect, so copied provider callback parameters cannot +/// authenticate another session. #[derive(Debug)] struct StoredOAuthState { state: OAuthState, - binding: OAuthStateBinding, + session_id: SessionId, + code_binding: OAuthCodeBinding, expires_at: Instant, } -/// Server-only binding for an OAuth authorization round trip. -/// -/// V1 preserves its existing state semantics. V2 binds the one-time callback -/// state to the attested transport session that initiated the redirect, so -/// copied provider callback parameters cannot authenticate another session. -#[derive(Debug)] -enum OAuthStateBinding { - LegacyV1, - TransportV2 { - session_id: SessionId, - code_binding: OAuthCodeBinding, - }, -} - -/// Provider-verifiable binding between one V2 authorization response and the +/// Provider-verifiable binding between one authorization response and the /// enclave session that initiated it. /// /// GitHub and Google bind the authorization code to a one-time PKCE verifier. /// Apple does not advertise PKCE, so its signed ID token carries a nonce -/// generated independently and stored alongside the state and V2 session. +/// generated independently and stored alongside the state and session. pub(crate) enum OAuthCodeBinding { Pkce(PkceCodeVerifier), AppleNonce(Zeroizing), @@ -137,20 +129,6 @@ impl OAuthStateStore { } } - async fn store( - &self, - csrf_token: &str, - state: OAuthState, - ) -> Result<(), OAuthStateCapacityError> { - self.store_with_binding( - csrf_token, - state, - OAuthStateBinding::LegacyV1, - Instant::now(), - ) - .await - } - async fn store_for_session( &self, csrf_token: &str, @@ -158,34 +136,16 @@ impl OAuthStateStore { session_id: SessionId, code_binding: OAuthCodeBinding, ) -> Result<(), OAuthStateCapacityError> { - self.store_with_binding( - csrf_token, - state, - OAuthStateBinding::TransportV2 { - session_id, - code_binding, - }, - Instant::now(), - ) - .await - } - - #[cfg(test)] - async fn store_at( - &self, - csrf_token: &str, - state: OAuthState, - now: Instant, - ) -> Result<(), OAuthStateCapacityError> { - self.store_with_binding(csrf_token, state, OAuthStateBinding::LegacyV1, now) + self.store_bound_at(csrf_token, state, session_id, code_binding, Instant::now()) .await } - async fn store_with_binding( + async fn store_bound_at( &self, csrf_token: &str, state: OAuthState, - binding: OAuthStateBinding, + session_id: SessionId, + code_binding: OAuthCodeBinding, now: Instant, ) -> Result<(), OAuthStateCapacityError> { let mut inner = self.inner.lock().await; @@ -201,7 +161,8 @@ impl OAuthStateStore { csrf_token.to_string(), StoredOAuthState { state, - binding, + session_id, + code_binding, expires_at: now .checked_add(self.ttl) .expect("OAuth state TTL must fit in Instant"), @@ -210,35 +171,23 @@ impl OAuthStateStore { Ok(()) } - async fn consume(&self, state: &OAuthState) -> bool { - self.take_with_binding(state, None, Instant::now()) - .await - .is_some() - } - async fn consume_for_session( &self, state: &OAuthState, session_id: SessionId, ) -> Option { - let stored_state = self - .take_with_binding(state, Some(session_id), Instant::now()) - .await?; - match stored_state.binding { - OAuthStateBinding::TransportV2 { code_binding, .. } => Some(code_binding), - OAuthStateBinding::LegacyV1 => None, - } - } - - #[cfg(test)] - async fn consume_at(&self, state: &OAuthState, now: Instant) -> bool { - self.take_with_binding(state, None, now).await.is_some() + self.take_at(state, session_id, Instant::now()) + .await + .map(|stored_state| stored_state.code_binding) } - async fn take_with_binding( + /// Removes the stored state only when the complete state and the + /// initiating session both match. A mismatch leaves it for the legitimate + /// callback. + async fn take_at( &self, state: &OAuthState, - session_id: Option, + session_id: SessionId, now: Instant, ) -> Option { let mut inner = self.inner.lock().await; @@ -246,20 +195,10 @@ impl OAuthStateStore { .entries .retain(|_, stored_state| stored_state.expires_at > now); - let matches = inner.entries.get(&state.csrf_token).is_some_and(|stored| { - stored.state == *state - && match (&stored.binding, session_id) { - (OAuthStateBinding::LegacyV1, None) => true, - ( - OAuthStateBinding::TransportV2 { - session_id: stored_session, - .. - }, - Some(expected_session), - ) => *stored_session == expected_session, - _ => false, - } - }); + let matches = inner + .entries + .get(&state.csrf_token) + .is_some_and(|stored| stored.state == *state && stored.session_id == session_id); matches .then(|| inner.entries.remove(&state.csrf_token)) .flatten() @@ -324,15 +263,6 @@ impl GithubProvider { )) } - pub async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - let (auth_url, csrf_token) = client - .authorize_url(CsrfToken::new_random) - .add_scope(Scope::new("user:email".to_string())) - .url(); - - (auth_url.to_string(), csrf_token) - } - pub(crate) async fn generate_bound_authorize_url( &self, client: &BasicClient, @@ -434,16 +364,6 @@ impl GoogleProvider { )) } - pub async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - let (auth_url, csrf_token) = client - .authorize_url(CsrfToken::new_random) - .add_scope(Scope::new("email".to_string())) - .add_scope(Scope::new("profile".to_string())) - .url(); - - (auth_url.to_string(), csrf_token) - } - pub(crate) async fn generate_bound_authorize_url( &self, client: &BasicClient, @@ -547,20 +467,6 @@ impl AppleProvider { )) } - pub async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - // For Apple Sign In, we'll primarily use the JS SDK on the frontend - // This URL is fallback for non-JS environments - let (auth_url, csrf_token) = client - .authorize_url(CsrfToken::new_random) - .add_scope(Scope::new("name".to_string())) - .add_scope(Scope::new("email".to_string())) - .add_extra_param("response_type", "code id_token") // Apple best practice - .add_extra_param("response_mode", "form_post") // Required by Apple - .url(); - - (auth_url.to_string(), csrf_token) - } - pub(crate) async fn generate_bound_authorize_url( &self, client: &BasicClient, @@ -570,8 +476,8 @@ impl AppleProvider { .authorize_url(CsrfToken::new_random) .add_scope(Scope::new("name".to_string())) .add_scope(Scope::new("email".to_string())) - .add_extra_param("response_type", "code id_token") - .add_extra_param("response_mode", "form_post") + .add_extra_param("response_type", "code id_token") // Apple best practice + .add_extra_param("response_mode", "form_post") // Required by Apple .add_extra_param("nonce", nonce) .url(); @@ -628,12 +534,6 @@ pub trait OAuthProvider: Send + Sync + 'static { None } - async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken); - async fn store_state( - &self, - csrf_token: &str, - state: OAuthState, - ) -> Result<(), OAuthStateCapacityError>; async fn store_state_for_session( &self, csrf_token: &str, @@ -641,7 +541,6 @@ pub trait OAuthProvider: Send + Sync + 'static { session_id: SessionId, code_binding: OAuthCodeBinding, ) -> Result<(), OAuthStateCapacityError>; - async fn consume_state(&self, state: &OAuthState) -> bool; async fn consume_state_for_session( &self, state: &OAuthState, @@ -681,18 +580,6 @@ impl OAuthProvider for GithubProvider { Some(self) } - async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - self.generate_authorize_url(client).await - } - - async fn store_state( - &self, - csrf_token: &str, - state: OAuthState, - ) -> Result<(), OAuthStateCapacityError> { - self.state_store.store(csrf_token, state).await - } - async fn store_state_for_session( &self, csrf_token: &str, @@ -705,10 +592,6 @@ impl OAuthProvider for GithubProvider { .await } - async fn consume_state(&self, state: &OAuthState) -> bool { - self.state_store.consume(state).await - } - async fn consume_state_for_session( &self, state: &OAuthState, @@ -736,18 +619,6 @@ impl OAuthProvider for GoogleProvider { Some(self) } - async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - self.generate_authorize_url(client).await - } - - async fn store_state( - &self, - csrf_token: &str, - state: OAuthState, - ) -> Result<(), OAuthStateCapacityError> { - self.state_store.store(csrf_token, state).await - } - async fn store_state_for_session( &self, csrf_token: &str, @@ -760,10 +631,6 @@ impl OAuthProvider for GoogleProvider { .await } - async fn consume_state(&self, state: &OAuthState) -> bool { - self.state_store.consume(state).await - } - async fn consume_state_for_session( &self, state: &OAuthState, @@ -791,18 +658,6 @@ impl OAuthProvider for AppleProvider { Some(self) } - async fn generate_authorize_url(&self, client: &BasicClient) -> (String, CsrfToken) { - self.generate_authorize_url(client).await - } - - async fn store_state( - &self, - csrf_token: &str, - state: OAuthState, - ) -> Result<(), OAuthStateCapacityError> { - self.state_store.store(csrf_token, state).await - } - async fn store_state_for_session( &self, csrf_token: &str, @@ -815,10 +670,6 @@ impl OAuthProvider for AppleProvider { .await } - async fn consume_state(&self, state: &OAuthState) -> bool { - self.state_store.consume(state).await - } - async fn consume_state_for_session( &self, state: &OAuthState, @@ -853,6 +704,34 @@ mod tests { } } + fn initiating_session() -> SessionId { + SessionId::from_bytes([10; 16]) + } + + impl OAuthStateStore { + async fn store_at( + &self, + csrf_token: &str, + state: OAuthState, + now: Instant, + ) -> Result<(), OAuthStateCapacityError> { + self.store_bound_at( + csrf_token, + state, + initiating_session(), + new_pkce_binding().1, + now, + ) + .await + } + + async fn consume_at(&self, state: &OAuthState, now: Instant) -> bool { + self.take_at(state, initiating_session(), now) + .await + .is_some() + } + } + fn assert_pkce_authorization(authorization: &BoundOAuthAuthorization) { let parameters: HashMap<_, _> = url::Url::parse(&authorization.auth_url) .unwrap() @@ -864,7 +743,7 @@ mod tests { Some("S256") ); let OAuthCodeBinding::Pkce(verifier) = &authorization.code_binding else { - panic!("V2 authorization must retain a PKCE verifier"); + panic!("authorization must retain a PKCE verifier"); }; assert_eq!( parameters.get("code_challenge").map(String::as_str), @@ -998,98 +877,66 @@ mod tests { } #[tokio::test] - async fn changed_redirect_is_rejected_without_consuming_v1_or_v2_state() { - for session_id in [None, Some(SessionId::from_bytes([42; 16]))] { - let store = OAuthStateStore::with_limits(Duration::from_secs(60), 2); - let now = Instant::now(); - let valid = state("redirect-bound-state", 1); - let binding = match session_id { - Some(session_id) => OAuthStateBinding::TransportV2 { - session_id, - code_binding: new_pkce_binding().1, - }, - None => OAuthStateBinding::LegacyV1, - }; - store - .store_with_binding(&valid.csrf_token, valid.clone(), binding, now) - .await - .unwrap(); - - for changed_redirect in ["https://auth.example/auth/callback", ""] { - let mut changed = valid.clone(); - changed.redirect_url = changed_redirect.to_string(); - assert!(store - .take_with_binding(&changed, session_id, now) - .await - .is_none()); - } - let consumed = store - .take_with_binding(&valid, session_id, now) - .await - .unwrap(); - assert_eq!(consumed.state.redirect_url, valid.redirect_url); - assert!(store - .take_with_binding(&valid, session_id, now) - .await - .is_none()); + async fn changed_redirect_is_rejected_without_consuming_state() { + let store = OAuthStateStore::with_limits(Duration::from_secs(60), 2); + let now = Instant::now(); + let valid = state("redirect-bound-state", 1); + store + .store_at(&valid.csrf_token, valid.clone(), now) + .await + .unwrap(); + + for changed_redirect in ["https://auth.example/auth/callback", ""] { + let mut changed = valid.clone(); + changed.redirect_url = changed_redirect.to_string(); + assert!(!store.consume_at(&changed, now).await); } + let consumed = store + .take_at(&valid, initiating_session(), now) + .await + .unwrap(); + assert_eq!(consumed.state.redirect_url, valid.redirect_url); + assert!(!store.consume_at(&valid, now).await); } #[tokio::test] - async fn oauth_state_protocol_and_v2_session_binding_are_non_consuming_on_mismatch() { + async fn session_binding_is_non_consuming_on_mismatch() { let store = OAuthStateStore::with_limits(Duration::from_secs(60), 2); let now = Instant::now(); - let v2_state = state("v2-state", 1); - let initiating_session = SessionId::from_bytes([10; 16]); + let oauth_state = state("session-bound-state", 1); let other_session = SessionId::from_bytes([11; 16]); store - .store_with_binding( - &v2_state.csrf_token, - v2_state.clone(), - OAuthStateBinding::TransportV2 { - session_id: initiating_session, - code_binding: OAuthCodeBinding::AppleNonce(Zeroizing::new( - "raw-nonce".to_string(), - )), - }, + .store_bound_at( + &oauth_state.csrf_token, + oauth_state.clone(), + initiating_session(), + OAuthCodeBinding::AppleNonce(Zeroizing::new("raw-nonce".to_string())), now, ) .await .unwrap(); - assert!(!store.consume_at(&v2_state, now).await); assert!(store - .take_with_binding(&v2_state, Some(other_session), now) + .take_at(&oauth_state, other_session, now) .await .is_none()); let consumed = store - .take_with_binding(&v2_state, Some(initiating_session), now) + .take_at(&oauth_state, initiating_session(), now) .await .unwrap(); - let OAuthStateBinding::TransportV2 { - code_binding: OAuthCodeBinding::AppleNonce(raw_nonce), - .. - } = consumed.binding - else { + let OAuthCodeBinding::AppleNonce(raw_nonce) = consumed.code_binding else { panic!("expected an Apple nonce binding"); }; assert_eq!(raw_nonce.as_str(), "raw-nonce"); - - let v1_state = state("v1-state", 2); - store - .store_at(&v1_state.csrf_token, v1_state.clone(), now) - .await - .unwrap(); assert!(store - .take_with_binding(&v1_state, Some(initiating_session), now) + .take_at(&oauth_state, initiating_session(), now) .await .is_none()); - assert!(store.consume_at(&v1_state, now).await); } #[tokio::test] - async fn v2_authorization_urls_bind_codes_without_changing_v1_urls() { + async fn authorization_urls_bind_codes_to_the_selected_redirect() { let github = GithubProvider { auth_url: "https://github.example/authorize".to_string(), token_url: "https://github.example/token".to_string(), @@ -1105,19 +952,6 @@ mod tests { .await .unwrap(); - let legacy_url = github.generate_authorize_url(&github_client).await.0; - let legacy_parameters: HashMap<_, _> = url::Url::parse(&legacy_url) - .unwrap() - .query_pairs() - .into_owned() - .collect(); - assert!(!legacy_parameters.contains_key("code_challenge")); - assert!(!legacy_parameters.contains_key("code_challenge_method")); - assert_eq!( - legacy_parameters.get("redirect_uri").map(String::as_str), - Some("https://maple.example/callback") - ); - let bound = github.generate_bound_authorize_url(&github_client).await; assert_pkce_authorization(&bound); assert!( @@ -1144,16 +978,13 @@ mod tests { .unwrap(); let bound = google.generate_bound_authorize_url(&google_client).await; assert_pkce_authorization(&bound); - for auth_url in [ - google.generate_authorize_url(&google_client).await.0, - bound.auth_url, - ] { - assert!(url::Url::parse(&auth_url) + assert!( + url::Url::parse(&bound.auth_url) .unwrap() .query_pairs() .any(|(key, value)| key == "redirect_uri" - && value == "https://maple.example/callback")); - } + && value == "https://maple.example/callback") + ); let apple = AppleProvider { auth_url: "https://apple.example/authorize".to_string(), @@ -1169,18 +1000,6 @@ mod tests { ) .await .unwrap(); - let legacy_url = apple.generate_authorize_url(&apple_client).await.0; - let legacy_parameters: HashMap<_, _> = url::Url::parse(&legacy_url) - .unwrap() - .query_pairs() - .into_owned() - .collect(); - assert!(!legacy_parameters.contains_key("nonce")); - assert_eq!( - legacy_parameters.get("redirect_uri").map(String::as_str), - Some("https://maple.example/callback") - ); - let bound = apple.generate_bound_authorize_url(&apple_client).await; let parameters: HashMap<_, _> = url::Url::parse(&bound.auth_url) .unwrap() @@ -1188,7 +1007,7 @@ mod tests { .into_owned() .collect(); let OAuthCodeBinding::AppleNonce(raw_nonce) = &bound.code_binding else { - panic!("Apple V2 authorization must retain the raw nonce"); + panic!("Apple authorization must retain the raw nonce"); }; let expected_nonce = hex::encode(Sha256::digest(raw_nonce.as_bytes())); assert_eq!( diff --git a/services/opensecret/src/password_policy_route_tests.rs b/services/opensecret/src/password_policy_route_tests.rs index 1a765a137..5df26b41a 100644 --- a/services/opensecret/src/password_policy_route_tests.rs +++ b/services/opensecret/src/password_policy_route_tests.rs @@ -92,7 +92,7 @@ fn v2_request( .into_parts(); parts .extensions - .insert(TransportSession::v2(SessionId::from_bytes([0xAA; 16]))); + .insert(TransportSession::new(SessionId::from_bytes([0xAA; 16]))); if let Some(token) = bearer_token { parts.extensions.insert( Credential::new(crate::transport_v2::envelope::CredentialKind::Bearer, token) @@ -224,7 +224,7 @@ async fn db_change_password_rejects_short_new_password_without_touching_the_cred .expect("password credential should open the active seed wrap"); let token = NewToken::new_with_auth_context( &authenticated.user, - TokenType::access_for_transport(true), + TokenType::TransportV2Access, &app_state, &authenticated.auth_context, ) diff --git a/services/opensecret/src/provider_cache.rs b/services/opensecret/src/provider_cache.rs index 95f2acd7e..b8b73163c 100644 --- a/services/opensecret/src/provider_cache.rs +++ b/services/opensecret/src/provider_cache.rs @@ -1,7 +1,4 @@ -use std::{ - fmt, - sync::{Arc, OnceLock}, -}; +use std::{fmt, sync::Arc}; use base64::{engine::general_purpose::STANDARD, Engine as _}; use hmac::{Hmac, Mac}; @@ -148,35 +145,6 @@ pub(crate) fn derive_provider_cache_namespaces( })) } -/// Legacy clients have no private cache root. Keep their Continuum namespaces -/// stable within this backend process, but secret from the host and other users. -/// Restarting the process intentionally cold-starts these namespaces. -pub(crate) fn legacy_continuum_cache_salt(verified_user_id: Uuid) -> String { - static ROOT: OnceLock = OnceLock::new(); - let root = ROOT.get_or_init(|| CacheNamespaceRoot(crate::encrypt::generate_random())); - let bytes = Zeroizing::new(derive_cache_namespace( - root, - verified_user_id, - CONTINUUM_CACHE_NAMESPACE_V1_LABEL, - )); - hex::encode(bytes.as_slice()) -} - -/// Legacy clients have no private cache root. Maple's dedicated instances get -/// their own process-secret namespace, separate from shared Tinfoil and other -/// providers even when the same authenticated user reaches both routes. -/// Restarting the process intentionally cold-starts these namespaces. -pub(crate) fn legacy_maple_user_cache_secret(verified_user_id: Uuid) -> String { - static ROOT: OnceLock = OnceLock::new(); - let root = ROOT.get_or_init(|| CacheNamespaceRoot(crate::encrypt::generate_random())); - let bytes = Zeroizing::new(derive_cache_namespace( - root, - verified_user_id, - MAPLE_CACHE_NAMESPACE_V1_LABEL, - )); - hex::encode(bytes.as_slice()) -} - fn derive_cache_namespace( root: &CacheNamespaceRoot, verified_user_id: Uuid, @@ -195,7 +163,6 @@ fn derive_cache_namespace( #[cfg(test)] mod tests { use super::*; - use sha2::Digest; #[test] fn cache_root_wire_encoding_is_canonical_and_redacted() { @@ -302,29 +269,4 @@ mod tests { assert_ne!(namespace, namespaces.tinfoil_user_cache_secret()); assert_ne!(namespace, namespaces.continuum_cache_salt()); } - - #[test] - fn legacy_maple_namespace_is_stable_user_bound_and_private() { - let user = Uuid::from_u128(1); - let namespace = legacy_maple_user_cache_secret(user); - assert_eq!(namespace.len(), 64); - assert_eq!(namespace, legacy_maple_user_cache_secret(user)); - assert_ne!( - namespace, - legacy_maple_user_cache_secret(Uuid::from_u128(2)) - ); - assert_ne!(namespace, legacy_continuum_cache_salt(user)); - // Tinfoil V1 uses this legacy UUID hash; Maple must not share it. - assert_ne!(namespace, hex::encode(Sha256::digest(user.as_bytes()))); - } - - #[test] - fn legacy_continuum_namespace_is_stable_and_user_bound() { - let user = Uuid::from_u128(1); - let salt = legacy_continuum_cache_salt(user); - assert_eq!(salt.len(), 64); - assert_eq!(salt, legacy_continuum_cache_salt(user)); - assert_ne!(salt, legacy_continuum_cache_salt(Uuid::from_u128(2))); - assert_ne!(salt, hex::encode(Sha256::digest(user.as_bytes()))); - } } diff --git a/services/opensecret/src/recovery_route_tests.rs b/services/opensecret/src/recovery_route_tests.rs index 77c74236c..9deac3e3e 100644 --- a/services/opensecret/src/recovery_route_tests.rs +++ b/services/opensecret/src/recovery_route_tests.rs @@ -157,14 +157,9 @@ fn v2_access_token( user: &crate::models::users::User, auth_context: &AuthContext, ) -> String { - NewToken::new_with_auth_context( - user, - TokenType::access_for_transport(true), - app_state, - auth_context, - ) - .expect("test v2 access token should issue") - .token + NewToken::new_with_auth_context(user, TokenType::TransportV2Access, app_state, auth_context) + .expect("test v2 access token should issue") + .token } /// Reproduces the inner request the transport-v2 gateway hands to the @@ -191,7 +186,7 @@ fn v2_request( .into_parts(); parts .extensions - .insert(TransportSession::v2(SessionId::from_bytes([0xAA; 16]))); + .insert(TransportSession::new(SessionId::from_bytes([0xAA; 16]))); if let Some(token) = bearer_token { parts.extensions.insert( Credential::new(crate::transport_v2::envelope::CredentialKind::Bearer, token) @@ -495,7 +490,7 @@ async fn recovery_rotate_and_disable_lifecycle_behaves_as_documented() { #[tokio::test] #[ignore = "requires RECOVERY_TEST_DATABASE_URL (or AEAD_TAMPER_TEST_DATABASE_URL) pointing at disposable migrated local Postgres"] -async fn recovery_management_rejects_unauthenticated_api_key_and_v1_contexts() { +async fn recovery_management_rejects_unauthenticated_api_key_and_gatewayless_contexts() { let fixture = authenticated_password_fixture("contexts").await; let app_state = &fixture.app_state; let app = recovery_router(app_state.clone()); @@ -525,52 +520,20 @@ async fn recovery_management_rejects_unauthenticated_api_key_and_v1_contexts() { "API-key contexts must not reach recovery management" ); - // v1 transport with a valid user JWT is rejected by the middleware gate - // before any recovery logic runs. - let v1_token = NewToken::new_with_auth_context( - &fixture.user, - TokenType::access_for_transport(false), - app_state, - &fixture.auth_context, - ) - .expect("v1 access token should issue") - .token; - let v1_request_value = Request::builder() + // A valid access token presented in an outer Authorization header, on a + // request the gateway never decrypted, is not a credential: no transport + // session was established and outer headers are never read. + let access_token = v2_access_token(app_state, &fixture.user, &fixture.auth_context); + let gatewayless = Request::builder() .method("GET") .uri("/protected/recovery-code") - .header("authorization", format!("Bearer {v1_token}")) + .header("authorization", format!("Bearer {access_token}")) .body(Body::empty()) .unwrap(); - let (mut v1_parts, v1_body) = v1_request_value.into_parts(); - v1_parts - .extensions - .insert(TransportSession::v1(Uuid::new_v4())); - let v1_transport = Request::from_parts(v1_parts, v1_body); - let v1_response = send(app.clone(), v1_transport).await; assert_eq!( - v1_response.status(), - StatusCode::BAD_REQUEST, - "v1 transport sessions must be rejected at the middleware boundary" - ); - - // A v1 session with an unparseable token must still be rejected with 400 - // (the transport gate), not 401 (the JWT middleware). This pins the - // middleware order: the v2-transport gate runs before JWT validation. - let garbage_v1 = Request::builder() - .method("GET") - .uri("/protected/recovery-code") - .header("authorization", "Bearer not-a-jwt") - .body(Body::empty()) - .unwrap(); - let (mut garbage_parts, garbage_body) = garbage_v1.into_parts(); - garbage_parts - .extensions - .insert(TransportSession::v1(Uuid::new_v4())); - let garbage_transport = Request::from_parts(garbage_parts, garbage_body); - assert_eq!( - send(app, garbage_transport).await.status(), - StatusCode::BAD_REQUEST, - "the v2-transport gate must run before the JWT middleware" + send(app, gatewayless).await.status(), + StatusCode::UNAUTHORIZED, + "a request that bypassed the gateway must not reach recovery management" ); assert!( @@ -745,91 +708,6 @@ async fn recovery_management_rejects_guest_and_oauth_only_users() { let _ = app_state.db.delete_user(&oauth_user); } -#[tokio::test] -#[ignore = "requires RECOVERY_TEST_DATABASE_URL (or AEAD_TAMPER_TEST_DATABASE_URL) pointing at disposable migrated local Postgres"] -async fn recovery_handlers_reject_v1_session_before_any_database_side_effect() { - let fixture = authenticated_password_fixture("handler-v1").await; - let app_state = &fixture.app_state; - - // Bare routes with no middleware: reproduces a mis-wired router where a - // v1 session reaches the handler. Each handler must still refuse before - // any database work. - let bare = |app_state: Arc| { - axum::Router::new() - .route( - "/protected/recovery-code", - axum::routing::get(crate::web::protected_routes::recovery_status) - .delete(crate::web::protected_routes::disable_recovery), - ) - .route( - "/protected/recovery-code/enroll", - axum::routing::post(crate::web::protected_routes::enroll_recovery), - ) - .route( - "/protected/recovery-code/rotate", - axum::routing::post(crate::web::protected_routes::rotate_recovery), - ) - .with_state(app_state) - }; - - // The decryption middleware stores the raw payload in extensions and the - // `Decrypted` extractor wraps it at extraction time. - let cases: Vec<(&'static str, &str)> = vec![ - ("GET", "/protected/recovery-code"), - ("DELETE", "/protected/recovery-code"), - ("POST", "/protected/recovery-code/enroll"), - ("POST", "/protected/recovery-code/rotate"), - ]; - - for (method, uri) in cases { - let (mut parts, request_body) = Request::builder() - .method(method) - .uri(uri) - .body(Body::empty()) - .unwrap() - .into_parts(); - parts - .extensions - .insert(TransportSession::v1(Uuid::new_v4())); - parts.extensions.insert(fixture.user.clone()); - parts.extensions.insert(fixture.auth_context.clone()); - parts - .extensions - .insert(crate::web::protected_routes::EnrollRecoveryRequest { - current_password: fixture.password.to_string(), - }); - parts - .extensions - .insert(crate::web::protected_routes::RotateRecoveryRequest { - current_password: fixture.password.to_string(), - }); - parts - .extensions - .insert(crate::web::protected_routes::DisableRecoveryRequest { - current_password: fixture.password.to_string(), - }); - // Status/disability paths carry no body; enroll/rotate payload types - // above cover the two decrypting handlers. Inserting every payload - // type is harmless: each handler consumes only its own. - let request = Request::from_parts(parts, request_body); - - let response = send(bare(app_state.clone()), request).await; - assert_eq!( - response.status(), - StatusCode::BAD_REQUEST, - "{method} {uri}: the handler must independently reject v1 sessions" - ); - } - - assert!(app_state - .db - .get_recovery_wrap(fixture.user.uuid) - .unwrap() - .is_none()); - - let _ = app_state.db.delete_user(&fixture.user); -} - #[tokio::test] #[ignore = "requires RECOVERY_TEST_DATABASE_URL (or AEAD_TAMPER_TEST_DATABASE_URL) pointing at disposable migrated local Postgres"] async fn recovery_error_responses_are_sanitized() { @@ -897,7 +775,7 @@ async fn recovery_error_responses_are_sanitized() { } // Call the handlers with the already-admitted context: running JWT // middleware again would reject the retired wrap before reaching step-up. - let session = TransportSession::v2(SessionId::from_bytes([0xAA; 16])); + let session = TransportSession::new(SessionId::from_bytes([0xAA; 16])); for result in [ enroll_recovery( State(app_state.clone()), @@ -1459,7 +1337,7 @@ async fn password_reset_v2_options_rejects_copied_reset_rows_across_users_and_pr #[tokio::test] #[ignore = "requires RECOVERY_TEST_DATABASE_URL (or AEAD_TAMPER_TEST_DATABASE_URL) pointing at disposable migrated local Postgres"] -async fn password_reset_v2_options_rejects_v1_and_missing_transport_sessions() { +async fn password_reset_v2_options_rejects_a_missing_transport_session() { let fixture = authenticated_password_fixture("v2-gate").await; let app_state = &fixture.app_state; let project = first_active_project(app_state); @@ -1470,22 +1348,9 @@ async fn password_reset_v2_options_rejects_v1_and_missing_transport_sessions() { insert_reset_request_fixture(app_state, &project, &fixture.user, "OFFFFF12", secret, 24); let proof = proof_fixture(&fixture.email, "OFFFFF12", secret, project.client_id); - // A v1 transport session presenting the entire valid proof is rejected - // before the handler can verify anything or reveal status. - let request_value = Request::builder() - .method("POST") - .uri("/password-reset/v2/options") - .body(Body::from(proof.request_body().to_string())) - .unwrap(); - let (mut v1_parts, v1_body) = request_value.into_parts(); - v1_parts - .extensions - .insert(TransportSession::v1(Uuid::new_v4())); - let v1_response = send(app.clone(), Request::from_parts(v1_parts, v1_body)).await; - assert_generic_bad_request(v1_response).await; - // A request that carries no transport session never established - // transport security and must not reach the handler either. + // transport security: even with the entire valid proof it is rejected + // before the handler can verify anything or reveal status. let sessionless = Request::builder() .method("POST") .uri("/password-reset/v2/options") @@ -2436,7 +2301,7 @@ async fn password_reset_v2_concurrent_destructive_completions_have_exactly_one_w #[tokio::test] #[ignore = "requires RECOVERY_TEST_DATABASE_URL (or AEAD_TAMPER_TEST_DATABASE_URL) pointing at disposable migrated local Postgres"] -async fn password_reset_v2_completion_rejects_v1_and_missing_transport_sessions() { +async fn password_reset_v2_completion_rejects_a_missing_transport_session() { let fixture = authenticated_password_fixture("v2-complete-gate").await; let app_state = &fixture.app_state; let project = first_active_project(app_state); @@ -2448,22 +2313,9 @@ async fn password_reset_v2_completion_rejects_v1_and_missing_transport_sessions( let proof = proof_fixture(&fixture.email, "PJJJJJJ1", secret, project.client_id); let body = complete_body(&proof, "recovery-gate-password", preserve_mode("MPLRC1")); - // A v1 transport session presenting the entire valid proof is rejected - // before the handler can verify anything or consume state. - let request_value = Request::builder() - .method("POST") - .uri("/password-reset/v2/complete") - .body(Body::from(body.to_string())) - .unwrap(); - let (mut v1_parts, v1_body) = request_value.into_parts(); - v1_parts - .extensions - .insert(TransportSession::v1(Uuid::new_v4())); - let v1_response = send(app.clone(), Request::from_parts(v1_parts, v1_body)).await; - assert_generic_bad_request(v1_response).await; - // A request that carries no transport session never established - // transport security and must not reach the handler either. + // transport security: even with the entire valid proof it is rejected + // before the handler can verify anything or consume state. let sessionless = Request::builder() .method("POST") .uri("/password-reset/v2/complete") diff --git a/services/opensecret/src/secret_cache_maintenance.rs b/services/opensecret/src/secret_cache_maintenance.rs deleted file mode 100644 index 9eadbe3ce..000000000 --- a/services/opensecret/src/secret_cache_maintenance.rs +++ /dev/null @@ -1,76 +0,0 @@ -use crate::AppState; -use std::sync::Arc; -use std::time::{Duration, Instant}; -use tokio::time::MissedTickBehavior; - -pub(crate) const SECRET_CACHE_MAINTENANCE_INTERVAL: Duration = Duration::from_secs(5 * 60); -pub(crate) const SESSION_RETIREMENT_BATCH_SIZE: usize = 4_096; - -pub(crate) async fn run(app_state: Arc) { - let first_tick = tokio::time::Instant::now() + SECRET_CACHE_MAINTENANCE_INTERVAL; - let mut interval = tokio::time::interval_at(first_tick, SECRET_CACHE_MAINTENANCE_INTERVAL); - interval.set_missed_tick_behavior(MissedTickBehavior::Skip); - - loop { - interval.tick().await; - purge_expired_secret_state(&app_state, Instant::now()).await; - } -} - -async fn purge_expired_secret_state(app_state: &AppState, now: Instant) { - // Never overlap the two cache locks. Pending key bytes are wiped in place; - // their destructors and deallocation run after releasing the write lock. - // Session values stay in stable Arc allocations and are both zeroized and - // deallocated after releasing their mutex. - let retired_pending = { - let mut pending = app_state.ephemeral_keys.write().await; - pending.retire_expired_at(now) - }; - let pending_count = retired_pending.removed_count(); - drop(retired_pending); - - // Snapshot the ordered expired suffix once. Repeatedly rescanning it for - // each batch would become quadratic when expired leased entries remain. - let candidates = { - let sessions = app_state.session_states.lock().await; - sessions.expired_unleased_keys_at(now) - }; - - let mut session_count = 0; - let mut batches = candidates.chunks(SESSION_RETIREMENT_BATCH_SIZE).peekable(); - while let Some(batch) = batches.next() { - let retired_sessions = { - let mut sessions = app_state.session_states.lock().await; - sessions.retire_expired_candidates_at(batch, now) - }; - session_count += retired_sessions.removed_count(); - drop(retired_sessions); - - // Give waiting requests a scheduling point between bounded lock holds. - if batches.peek().is_some() { - tokio::task::yield_now().await; - } - } - - if pending_count != 0 || session_count != 0 { - tracing::debug!( - pending_attestations = pending_count, - encryption_sessions = session_count, - "Purged expired secret state" - ); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn maintenance_policy_is_five_minutes_with_bounded_session_batches() { - assert_eq!( - SECRET_CACHE_MAINTENANCE_INTERVAL, - Duration::from_secs(5 * 60) - ); - assert_eq!(SESSION_RETIREMENT_BATCH_SIZE, 4_096); - } -} diff --git a/services/opensecret/src/security_invariants.rs b/services/opensecret/src/security_invariants.rs index b733ab84c..c747de8d9 100644 --- a/services/opensecret/src/security_invariants.rs +++ b/services/opensecret/src/security_invariants.rs @@ -528,8 +528,8 @@ fn refresh_route_preserves_signed_auth_context_without_recomputing_binding() { for required_pattern in [ "AuthContext::from_claims(&claims)", "verify_seed_wrap_for_auth_context(&user, &auth_context)", - "TokenType::access_for_transport(session_id.is_v2())", - "TokenType::refresh_for_transport(session_id.is_v2())", + "TokenType::TransportV2Access", + "TokenType::TransportV2Refresh", ] { assert!( refresh_body.contains(required_pattern), @@ -894,8 +894,8 @@ fn password_credential_lifecycle_rewraps_seed_and_reissues_tokens() { ".update_user_password_and_seed_wrap(", "&auth_context", "NewToken::new_with_auth_context(", - "TokenType::access_for_transport(session_id.is_v2())", - "TokenType::refresh_for_transport(session_id.is_v2())", + "TokenType::TransportV2Access", + "TokenType::TransportV2Refresh", "&new_auth_context", ] { assert!( @@ -1091,8 +1091,8 @@ fn password_registration_and_login_issue_tokens_only_after_seed_wrap_verificatio for required_pattern in [ ".authenticate_user(", "NewToken::new_with_auth_context(", - "TokenType::access_for_transport(is_transport_v2)", - "TokenType::refresh_for_transport(is_transport_v2)", + "TokenType::TransportV2Access", + "TokenType::TransportV2Refresh", "&authenticated_user.auth_context", ] { assert!( @@ -1517,15 +1517,8 @@ fn assert_patterns_in_order(source: &str, patterns: &[&str]) { } } -const RECOVERY_MANAGEMENT_HANDLERS: &[&str] = &[ - "recovery_status", - "enroll_recovery", - "rotate_recovery", - "disable_recovery", -]; - #[test] -fn recovery_management_routes_require_jwt_and_v2_transport() { +fn recovery_management_routes_require_jwt_and_encrypted_requests() { let protected_routes = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/web/protected_routes.rs"); let contents = @@ -1566,12 +1559,6 @@ fn recovery_management_routes_require_jwt_and_v2_transport() { ); } - // The v2-transport gate is part of the recovery sub-router itself, so v1 - // sessions are rejected before user JWT validation touches the database. - assert!( - router_body.contains("from_fn(require_transport_v2)"), - "the recovery sub-router must apply the v2-transport gate" - ); assert!( router_body.contains("from_fn_with_state(app_state.clone(), validate_jwt)"), "the recovery sub-router must apply the user-JWT middleware" @@ -1588,32 +1575,96 @@ fn recovery_management_routes_require_jwt_and_v2_transport() { ); } +/// The listener serves the application only through the Transport V2 gateway. +/// A router that mounted an application route directly would hand a plaintext +/// HTTP caller a route whose handlers assume an authenticated, decrypted +/// envelope. #[test] -fn recovery_handlers_enforce_transport_and_user_guards_before_any_logic() { - let protected_routes = - Path::new(env!("CARGO_MANIFEST_DIR")).join("src/web/protected_routes.rs"); - let contents = - fs::read_to_string(&protected_routes).expect("protected routes source should be readable"); +fn application_routes_are_served_only_behind_the_transport_v2_gateway() { + let main_contents = + fs::read_to_string(Path::new(env!("CARGO_MANIFEST_DIR")).join("src/main.rs")) + .expect("main source should be readable"); - for handler in RECOVERY_MANAGEMENT_HANDLERS { - let signature = format!("pub async fn {handler}("); - let body = extract_function_body(&contents, &signature); + let public_body = extract_function_body(&main_contents, "fn public_routes"); + for required_pattern in [ + "health_routes()", + "attestation_routes::router(", + "web::remote::relay::router(", + "transport_v2_gateway.router()", + ] { + assert!( + public_body.contains(required_pattern), + "the listener's router must serve `{required_pattern}`" + ); + } + assert_eq!( + public_body.matches(".merge(").count(), + 3, + "the listener's router must serve exactly its four plaintext surfaces" + ); + for forbidden_pattern in [ + "application_routes(", + "transport_v2_application(", + "native_handoff_routes(", + "_routes(app_state", + ] { + assert!( + !public_body.contains(forbidden_pattern), + "the listener's router must not mount `{forbidden_pattern}` in plaintext" + ); + } - let do_recovery_work = - body.contains("encrypt_response") || body.contains("db.get_recovery_wrap"); - if !do_recovery_work { - continue; - } + // The application is composed once, for the gateway, and nothing else + // turns it into a served router. + assert_eq!( + main_contents.matches("application_routes(").count(), + 2, + "application_routes must be defined once and used only by the gateway application" + ); + let gateway_application_body = + extract_function_body(&main_contents, "fn transport_v2_application"); + assert!(gateway_application_body.contains("application_routes(app_state.clone())")); + assert_eq!( + main_contents.matches("transport_v2_application(").count(), + 2, + "the gateway application must be built once, for the gateway" + ); + let main_body = extract_function_body(&main_contents, "async fn main"); + assert_patterns_in_order( + main_body, + &[ + "TransportV2Gateway::new(", + "transport_v2_application(app_state.clone())", + "public_routes(app_state.clone(), &transport_v2_gateway)", + "axum::serve(listener, app.into_make_service())", + ], + ); - let guard_index = body - .find("require_v2_transport_session(&transport_session)?;") - .unwrap_or_else(|| panic!("{handler} must call the v2-transport guard first")); - let logic_index = body - .find("db.") - .unwrap_or_else(|| body.rfind("await").expect("handler should await work")); + // The application's own boundary fails closed without the gateway's + // session marker, and its authentication reads only envelope credentials. + let middleware = fs::read_to_string( + Path::new(env!("CARGO_MANIFEST_DIR")).join("src/web/encryption_middleware.rs"), + ) + .expect("encryption middleware source should be readable"); + let decrypt_body = extract_function_body(&middleware, "pub async fn decrypt_request"); + assert_patterns_in_order( + decrypt_body, + &[ + "request.extensions().get::().is_none()", + "return Err(ApiError::BadRequest);", + "next.run(request)", + ], + ); + for (path, forbidden_pattern) in [ + ("src/jwt.rs", "header::AUTHORIZATION"), + ("src/web/openai_auth.rs", "header::AUTHORIZATION"), + ("src/web/encryption_middleware.rs", "x-session-id"), + ] { + let source = fs::read_to_string(Path::new(env!("CARGO_MANIFEST_DIR")).join(path)) + .expect("source should be readable"); assert!( - guard_index < logic_index, - "{handler} must reject non-v2 transports before opening or writing recovery state" + !source.contains(forbidden_pattern), + "{path} must not read a plaintext `{forbidden_pattern}`" ); } } @@ -1706,7 +1757,7 @@ fn recovery_stepup_gates_before_seed_open_and_insert() { } #[test] -fn password_reset_v2_options_requires_v2_transport_and_shared_readonly_proof() { +fn password_reset_v2_options_requires_shared_readonly_proof() { let login_routes = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/web/login_routes.rs"); let contents = fs::read_to_string(&login_routes).expect("login route source should be readable"); @@ -1735,37 +1786,21 @@ fn password_reset_v2_options_requires_v2_transport_and_shared_readonly_proof() { !sub_router_body.contains(".with_state("), "the options sub-router must keep its typed state until the login router erases it" ); - // The v2-transport gate must be the outermost layer on the sub-router: - // the route is declared with its encrypted-request layer, and the - // v2-transport gate is applied after it, so a v1 session is rejected - // before any request body is decrypted or proof is verified. - assert!( - sub_router_body.contains("from_fn(require_transport_v2)"), - "the options sub-router must apply the v2-transport gate" - ); assert_patterns_in_order( sub_router_body, &[ "post(password_reset_v2_options)", "decrypt_request::", - ".route_layer(from_fn(require_transport_v2))", ], ); let handler_body = extract_function_body(&contents, "pub async fn password_reset_v2_options"); - let guard_index = handler_body - .find("require_v2_transport_session(&transport_session)?;") - .expect("the v2 options handler must call the v2-transport guard first"); let proof_index = handler_body .find("verify_password_reset_proof(") .expect("the v2 options handler must reuse the shared proof verification"); let reveal_index = handler_body .find("recovery_wrap_exists") .expect("the v2 options handler must reveal recovery enrollment"); - assert!( - guard_index < proof_index, - "the v2 options handler must reject non-v2 transports before proof verification" - ); assert!( proof_index < reveal_index, "the v2 options handler must reveal recovery enrollment only after the proof" @@ -1808,7 +1843,7 @@ fn password_reset_v2_options_requires_v2_transport_and_shared_readonly_proof() { } #[test] -fn password_reset_v2_complete_requires_v2_transport_and_guarded_completion() { +fn password_reset_v2_complete_requires_guarded_completion() { let login_routes = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/web/login_routes.rs"); let contents = fs::read_to_string(&login_routes).expect("login route source should be readable"); @@ -1825,22 +1860,15 @@ fn password_reset_v2_complete_requires_v2_transport_and_guarded_completion() { && sub_router_body.contains("decrypt_request::"), "the completion sub-router must wire the route with its encrypted-request layer" ); - // The v2-transport gate must be the outermost layer on the sub-router so - // a v1 session is rejected before any request body is decrypted or proof - // is verified. assert_patterns_in_order( sub_router_body, &[ "post(password_reset_v2_complete)", "decrypt_request::", - ".route_layer(from_fn(require_transport_v2))", ], ); let handler_body = extract_function_body(&contents, "pub async fn password_reset_v2_complete"); - let guard_index = handler_body - .find("require_v2_transport_session(&transport_session)?;") - .expect("the completion handler must call the v2-transport guard first"); let acknowledge_index = handler_body .find("acknowledge_data_loss") .expect("the completion handler must gate destructive reset on an explicit acknowledgment"); @@ -1850,10 +1878,6 @@ fn password_reset_v2_complete_requires_v2_transport_and_guarded_completion() { let proof_index = handler_body .find("verify_password_reset_proof(") .expect("the completion handler must reuse the shared proof verification"); - assert!( - guard_index < acknowledge_index, - "the completion handler must reject non-v2 transports before mode dispatch" - ); assert!( acknowledge_index < project_index, "the completion handler must require the destructive acknowledgment before any account lookup" diff --git a/services/opensecret/src/transport_v2/client_app_tests.rs b/services/opensecret/src/transport_v2/client_app_tests.rs index 08284e878..2374b7c14 100644 --- a/services/opensecret/src/transport_v2/client_app_tests.rs +++ b/services/opensecret/src/transport_v2/client_app_tests.rs @@ -26,10 +26,7 @@ async fn assert_client_app_gateway_roundtrip( // Attribution is telemetry only: transport credential identity // and kind must survive unchanged, including an absent credential. assert!(request.extensions().get::() == expected_credential.as_ref()); - assert!(request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2)); + assert!(request.extensions().get::().is_some()); (StatusCode::OK, "attribution-inspected") } }), diff --git a/services/opensecret/src/transport_v2/gateway.rs b/services/opensecret/src/transport_v2/gateway.rs index 19c3aff95..f3d3f1066 100644 --- a/services/opensecret/src/transport_v2/gateway.rs +++ b/services/opensecret/src/transport_v2/gateway.rs @@ -460,7 +460,7 @@ fn build_application_request( } request .extensions_mut() - .insert(TransportSession::v2(session_id)); + .insert(TransportSession::new(session_id)); request.extensions_mut().insert(request_id); if let Some(credential) = parts.credential { request.extensions_mut().insert(credential); @@ -1097,10 +1097,7 @@ mod tests { assert_eq!(request.method(), Method::POST); assert_eq!(request.uri().query(), Some("answer=42")); assert_eq!(request.headers().get("x-logical").unwrap(), "present"); - assert!(request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2)); + assert!(request.extensions().get::().is_some()); assert_eq!( request.extensions().get::(), Some(&RequestId::from_bytes([0x11; 16])) @@ -1445,7 +1442,7 @@ mod tests { let dispatches = Arc::clone(&dispatches); async move { dispatches.fetch_add(1, Ordering::SeqCst); - ApiError::SessionNotFound.into_response() + ApiError::AccessTokenExpired.into_response() } } }), @@ -1464,8 +1461,8 @@ mod tests { .unwrap(); let records = decrypt_records(&test.client, request_id, response).await; assert!(matches!(&records[0], ResponseRecord::Start(start) - if start.status() == 400 && start.headers().iter().any(|header| - header.name() == crate::ERROR_CODE_HEADER && header.value() == "session_not_found"))); + if start.status() == 401 && start.headers().iter().any(|header| + header.name() == crate::ERROR_CODE_HEADER && header.value() == "access_token_expired"))); assert_eq!(dispatches.load(Ordering::SeqCst), 1); let response = router .oneshot(outer_request(test.server.id(), &test.routing_key, record)) diff --git a/services/opensecret/src/transport_v2/oauth_callback_tests.rs b/services/opensecret/src/transport_v2/oauth_callback_tests.rs index a58fc3594..1f04f80b3 100644 --- a/services/opensecret/src/transport_v2/oauth_callback_tests.rs +++ b/services/opensecret/src/transport_v2/oauth_callback_tests.rs @@ -2,55 +2,37 @@ // Selection checks need no provider exchange. Completion checks below use only // loopback providers and a disposable database, with no real OAuth credentials. -async fn oauth_selection_v1_request( +/// Sends one plaintext request straight to the application router, the way a +/// caller that bypassed the Transport V2 gateway would. Nothing but the gateway +/// can attach a transport session, so the application must refuse it. +async fn direct_application_request( application: &Router<()>, - session_id: uuid::Uuid, - session_key: &[u8; 32], + method: Method, target: &str, - payload: &serde_json::Value, -) -> (u16, serde_json::Value) { - use chacha20poly1305::{aead::Aead, ChaCha20Poly1305, KeyInit, Nonce}; - - let cipher = ChaCha20Poly1305::new_from_slice(session_key).unwrap(); - let nonce = crate::encrypt::generate_random::<12>(); - let mut encrypted = nonce.to_vec(); - encrypted.extend_from_slice( - &cipher - .encrypt( - Nonce::from_slice(&nonce), - serde_json::to_vec(payload).unwrap().as_slice(), - ) - .unwrap(), - ); - let request = Request::builder() - .method(Method::POST) - .uri(target) - .header(header::CONTENT_TYPE, "application/json") - .header("x-session-id", session_id.to_string()) - .body(Body::from( - serde_json::to_vec(&serde_json::json!({ "encrypted": STANDARD.encode(encrypted) })) - .unwrap(), - )) - .unwrap(); - let response = application.clone().oneshot(request).await.unwrap(); - let status = response.status().as_u16(); - let body = to_bytes(response.into_body(), 64 * 1024).await.unwrap(); - let body: serde_json::Value = serde_json::from_slice(&body).unwrap(); - if status != 200 { - // V1 retains its existing plaintext error projection. - return (status, body); + payload: Option<&serde_json::Value>, + bearer: Option<&str>, +) -> u16 { + let mut builder = Request::builder().method(method).uri(target); + if let Some(bearer) = bearer { + builder = builder.header(header::AUTHORIZATION, format!("Bearer {bearer}")); } - let encrypted = STANDARD - .decode(body["encrypted"].as_str().unwrap()) - .unwrap(); - let (nonce, ciphertext) = encrypted.split_at(12); - let plaintext = cipher - .decrypt(Nonce::from_slice(nonce), ciphertext) - .unwrap(); - (status, serde_json::from_slice(&plaintext).unwrap()) + let body = match payload { + Some(payload) => { + builder = builder.header(header::CONTENT_TYPE, "application/json"); + Body::from(serde_json::to_vec(payload).unwrap()) + } + None => Body::empty(), + }; + application + .clone() + .oneshot(builder.body(body).unwrap()) + .await + .unwrap() + .status() + .as_u16() } -async fn oauth_selection_v2_request( +async fn oauth_selection_request( gateway: &Router<()>, session: &TestSession, request_number: u8, @@ -100,7 +82,7 @@ async fn oauth_selection_v2_request( #[tokio::test] #[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_oauth_callback_selection_v1_v2() { +async fn db_oauth_callback_selection() { use crate::{ db::setup_test_db, models::{ @@ -110,7 +92,6 @@ async fn db_oauth_callback_selection_v1_v2() { project_settings::{AppleOAuthSettings, OAuthProviderSettings, OAuthSettings}, }, web::{ - attestation_routes::SessionState, oauth_routes, platform::common::{ PROJECT_APPLE_OAUTH_SECRET, PROJECT_GITHUB_OAUTH_SECRET, @@ -209,15 +190,9 @@ async fn db_oauth_callback_selection_v1_v2() { } let application = oauth_routes(Arc::clone(&app_state)); - let session_v1_id = uuid::Uuid::new_v4(); - let session_v1_key = crate::encrypt::generate_random::<32>(); - app_state - .store_session_state(session_v1_id, SessionState::new(session_v1_key)) - .await - .unwrap(); - let session_v2 = test_session(0xD1); + let session = test_session(0xD1); let sessions = Arc::new(SessionStore::new(NonZeroUsize::new(2).unwrap())); - sessions.insert(Arc::clone(&session_v2.server)).unwrap(); + sessions.insert(Arc::clone(&session.server)).unwrap(); let gateway = request_router(application.clone(), sessions); let mut request_number = 0; @@ -246,64 +221,59 @@ async fn db_oauth_callback_selection_v1_v2() { if let Some(selection) = selection { payload["redirect_url"] = selection; } - let v1 = oauth_selection_v1_request( - &application, - session_v1_id, - &session_v1_key, - &target, - &payload, - ) - .await; + // The same request sent around the gateway never starts a flow. + assert_eq!( + direct_application_request( + &application, + Method::POST, + &target, + Some(&payload), + None, + ) + .await, + 400, + "{provider} must refuse a request that bypassed the gateway" + ); request_number += 1; - let v2 = oauth_selection_v2_request( - &gateway, - &session_v2, - request_number, - &target, - &payload, - ) - .await; - for (transport, (status, response)) in [(1, v1), (2, v2)] { - let Some(expected) = expected else { - assert_eq!( - status, 400, - "{provider} V{transport} must reject unlisted callbacks" - ); - assert!(response.get("auth_url").is_none()); - assert!(response.get("state").is_none()); - continue; - }; + let (status, response) = + oauth_selection_request(&gateway, &session, request_number, &target, &payload) + .await; + let Some(expected) = expected else { + assert_eq!(status, 400, "{provider} must reject unlisted callbacks"); + assert!(response.get("auth_url").is_none()); + assert!(response.get("state").is_none()); + continue; + }; + assert_eq!(status, 200, "{provider} initiation should succeed"); + let auth_url = url::Url::parse(response["auth_url"].as_str().unwrap()).unwrap(); + let query: std::collections::HashMap<_, _> = auth_url.query_pairs().collect(); + if provider == "apple" { assert_eq!( - status, 200, - "{provider} V{transport} initiation should succeed" + query.get("client_id").map(|value| value.as_ref()), + Some("oauth-selection.services") ); - let auth_url = url::Url::parse(response["auth_url"].as_str().unwrap()).unwrap(); - let query: std::collections::HashMap<_, _> = auth_url.query_pairs().collect(); - if provider == "apple" { - assert_eq!(query.get("client_id").map(|value| value.as_ref()), Some("oauth-selection.services")); - } - assert_eq!( - query.get("redirect_uri").map(|value| value.as_ref()), - Some(expected) - ); - let opaque_state = response["state"].as_str().unwrap(); - assert_eq!( - query.get("state").map(|value| value.as_ref()), - Some(opaque_state) - ); - let state: serde_json::Value = serde_json::from_slice( - &base64::engine::general_purpose::URL_SAFE_NO_PAD - .decode(opaque_state) - .unwrap(), - ) - .unwrap(); - assert_eq!(state["client_id"], project.client_id.to_string()); - assert_eq!(state["redirect_url"], expected); - assert!(!state["csrf_token"].as_str().unwrap().is_empty()); - if provider != "apple" { - assert_eq!(query.contains_key("code_challenge"), transport == 2); - } } + assert_eq!( + query.get("redirect_uri").map(|value| value.as_ref()), + Some(expected) + ); + let opaque_state = response["state"].as_str().unwrap(); + assert_eq!( + query.get("state").map(|value| value.as_ref()), + Some(opaque_state) + ); + let state: serde_json::Value = serde_json::from_slice( + &base64::engine::general_purpose::URL_SAFE_NO_PAD + .decode(opaque_state) + .unwrap(), + ) + .unwrap(); + assert_eq!(state["client_id"], project.client_id.to_string()); + assert_eq!(state["redirect_url"], expected); + assert!(!state["csrf_token"].as_str().unwrap().is_empty()); + // GitHub and Google bind the code with PKCE; Apple with a nonce. + assert_eq!(query.contains_key("code_challenge"), provider != "apple"); + assert_eq!(query.contains_key("nonce"), provider == "apple"); } } app_state.db.delete_org_project(&project).unwrap(); @@ -396,13 +366,10 @@ impl Drop for OAuthCompletionMock { } } -async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { +async fn oauth_callback_completion_case(provider: &str) { use crate::{ db::setup_test_db, - jwt::{ - validate_token, AuthContext, TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH, - USER_ACCESS, USER_REFRESH, - }, + jwt::{validate_token, AuthContext, TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH}, models::{ org_project_secrets::NewOrgProjectSecret, org_projects::NewOrgProject, @@ -412,7 +379,6 @@ async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { }, oauth::{GithubProvider, GoogleProvider, OAuthManager}, web::{ - attestation_routes::SessionState, oauth_routes, platform::common::{PROJECT_GITHUB_OAUTH_SECRET, PROJECT_GOOGLE_OAUTH_SECRET}, }, @@ -526,34 +492,16 @@ async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { .unwrap(); let application = oauth_routes(Arc::clone(&app_state)); - let session_v1_id = uuid::Uuid::new_v4(); - let session_v1_key = crate::encrypt::generate_random::<32>(); - app_state - .store_session_state(session_v1_id, SessionState::new(session_v1_key)) - .await - .unwrap(); - let session_v2 = test_session(0xD2); + let session = test_session(0xD2); + let other_session = test_session(0xD3); let sessions = Arc::new(SessionStore::new(NonZeroUsize::new(2).unwrap())); - sessions.insert(Arc::clone(&session_v2.server)).unwrap(); - let gateway = request_router(application.clone(), sessions); + sessions.insert(Arc::clone(&session.server)).unwrap(); + sessions.insert(Arc::clone(&other_session.server)).unwrap(); + let gateway = request_router(application, sessions); let request = |number, target: String, payload: serde_json::Value| { - let application = &application; let gateway = &gateway; - let session_v2 = &session_v2; - async move { - if is_v2 { - oauth_selection_v2_request(gateway, session_v2, number, &target, &payload).await - } else { - oauth_selection_v1_request( - application, - session_v1_id, - &session_v1_key, - &target, - &payload, - ) - .await - } - } + let session = &session; + async move { oauth_selection_request(gateway, session, number, &target, &payload).await } }; let initiate_target = format!("/auth/{provider}"); let initiate_payload = serde_json::json!({ @@ -587,15 +535,21 @@ async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { "code": "callback-completion-code", "state": initiation["state"], }); + // The callback state is bound to the session that initiated it: another + // attested session cannot complete it, and its attempt consumes nothing. + assert_eq!( + oauth_selection_request(&gateway, &other_session, 3, &callback_target, &callback_payload) + .await + .0, + 400, + "{provider} callback must be refused from another session" + ); + assert!(mock.token_requests.lock().unwrap().is_empty()); let (status, response) = request(3, callback_target.clone(), callback_payload.clone()).await; assert_eq!(status, 200, "{provider} callback must complete after settings change"); assert_eq!(response["id"], user.uuid.to_string()); assert_eq!(response["email"], email); - let audiences = if is_v2 { - [TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH] - } else { - [USER_ACCESS, USER_REFRESH] - }; + let audiences = [TRANSPORT_V2_USER_ACCESS, TRANSPORT_V2_USER_REFRESH]; for (field, audience) in ["access_token", "refresh_token"].into_iter().zip(audiences) { let claims = validate_token(response[field].as_str().unwrap(), &app_state, audience).unwrap(); assert_eq!(claims.sub, user.uuid.to_string()); @@ -621,15 +575,13 @@ async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { assert_eq!(form.get("redirect_uri"), Some(&selected)); assert_eq!(form.get("code").map(String::as_str), Some("callback-completion-code")); assert_eq!(form.get("grant_type").map(String::as_str), Some("authorization_code")); - if is_v2 { - let verifier = form.get("code_verifier").expect("V2 callback must send its PKCE verifier"); - let challenge = base64::engine::general_purpose::URL_SAFE_NO_PAD - .encode(Sha256::digest(verifier.as_bytes())); - assert_eq!(query.get("code_challenge").unwrap(), &challenge); - assert_eq!(query.get("code_challenge_method").map(|v| v.as_ref()), Some("S256")); - } else { - assert!(!form.contains_key("code_verifier")); - } + let verifier = form + .get("code_verifier") + .expect("the callback must send its PKCE verifier"); + let challenge = base64::engine::general_purpose::URL_SAFE_NO_PAD + .encode(Sha256::digest(verifier.as_bytes())); + assert_eq!(query.get("code_challenge").unwrap(), &challenge); + assert_eq!(query.get("code_challenge_method").map(|v| v.as_ref()), Some("S256")); } assert_eq!(mock.user_requests.load(Ordering::SeqCst), 1); @@ -645,32 +597,16 @@ async fn oauth_callback_completion_case(provider: &str, is_v2: bool) { #[tokio::test] #[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_oauth_callback_completion_github_v1() { - tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("github", false)) - .await - .expect("GitHub V1 callback fixture timed out"); -} - -#[tokio::test] -#[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_oauth_callback_completion_github_v2() { - tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("github", true)) - .await - .expect("GitHub V2 callback fixture timed out"); -} - -#[tokio::test] -#[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_oauth_callback_completion_google_v1() { - tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("google", false)) +async fn db_oauth_callback_completion_github() { + tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("github")) .await - .expect("Google V1 callback fixture timed out"); + .expect("GitHub callback fixture timed out"); } #[tokio::test] #[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_oauth_callback_completion_google_v2() { - tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("google", true)) +async fn db_oauth_callback_completion_google() { + tokio::time::timeout(Duration::from_secs(30), oauth_callback_completion_case("google")) .await - .expect("Google V2 callback fixture timed out"); + .expect("Google callback fixture timed out"); } diff --git a/services/opensecret/src/transport_v2/recovery_transport_tests.rs b/services/opensecret/src/transport_v2/recovery_transport_tests.rs index 5d06080e3..7e9a6544a 100644 --- a/services/opensecret/src/transport_v2/recovery_transport_tests.rs +++ b/services/opensecret/src/transport_v2/recovery_transport_tests.rs @@ -1,60 +1,11 @@ // Included in gateway::tests to reuse the real encrypted request/response harness. -// The recovery route tests hand the inner router a V2 session extension; these -// drive the production application composition through the real V2 gateway and -// the real V1 encryption middleware against a disposable database. +// The recovery route tests hand the inner router a transport session extension; +// these drive the production application composition through the real gateway +// against a disposable database. -/// Sends one request through the V1 encryption middleware. Bodyless requests -/// still carry the session header so the middleware sees a V1 caller. -async fn recovery_v1_request( - application: &Router<()>, - session_id: uuid::Uuid, - session_key: &[u8; 32], - method: Method, - target: &str, - payload: Option<&serde_json::Value>, - bearer: &str, -) -> (u16, serde_json::Value) { - use chacha20poly1305::{aead::Aead, ChaCha20Poly1305, KeyInit, Nonce}; - - let cipher = ChaCha20Poly1305::new_from_slice(session_key).unwrap(); - let mut builder = Request::builder() - .method(method) - .uri(target) - .header("x-session-id", session_id.to_string()) - .header(header::AUTHORIZATION, format!("Bearer {bearer}")); - let body = match payload { - Some(payload) => { - let nonce = crate::encrypt::generate_random::<12>(); - let mut encrypted = nonce.to_vec(); - encrypted.extend_from_slice( - &cipher - .encrypt( - Nonce::from_slice(&nonce), - serde_json::to_vec(payload).unwrap().as_slice(), - ) - .unwrap(), - ); - builder = builder.header(header::CONTENT_TYPE, "application/json"); - Body::from( - serde_json::to_vec(&serde_json::json!({ "encrypted": STANDARD.encode(encrypted) })) - .unwrap(), - ) - } - None => Body::empty(), - }; - let response = application - .clone() - .oneshot(builder.body(body).unwrap()) - .await - .unwrap(); - let status = response.status().as_u16(); - let body = to_bytes(response.into_body(), 64 * 1024).await.unwrap(); - (status, serde_json::from_slice(&body).unwrap()) -} - -/// Sends one request through the V2 gateway and returns the authenticated +/// Sends one request through the gateway and returns the authenticated /// inner status and JSON body. -async fn recovery_v2_request( +async fn recovery_request( gateway: &Router<()>, session: &TestSession, request_number: &mut u8, @@ -112,7 +63,7 @@ async fn recovery_v2_request( #[tokio::test] #[ignore = "requires AEAD_TAMPER_TEST_DATABASE_URL pointing at disposable migrated local Postgres"] -async fn db_recovery_flow_v1_rejected_v2_completes() { +async fn db_recovery_flow_completes_only_through_the_gateway() { use crate::{ db::setup_test_db, generate_reset_hash, @@ -122,7 +73,6 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { org_projects::NewOrgProject, orgs::NewOrg, password_reset::NewPasswordResetRequest, }, seed_wrapping::password_reset_code_mac, - web::attestation_routes::SessionState, AppMode, AppStateBuilder, }; @@ -175,17 +125,14 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { let seed_before = app_state .decrypt_seed_for_auth_context(&user, &authenticated.auth_context) .unwrap(); - let token = |is_v2: bool| { - NewToken::new_with_auth_context( - &user, - TokenType::access_for_transport(is_v2), - &app_state, - &authenticated.auth_context, - ) - .unwrap() - .token - }; - let (v1_token, v2_token) = (token(false), token(true)); + let access_token = NewToken::new_with_auth_context( + &user, + TokenType::TransportV2Access, + &app_state, + &authenticated.auth_context, + ) + .unwrap() + .token; let reset_code = "TRANSP12"; let reset_secret = "recovery-transport-reset-secret"; @@ -209,24 +156,22 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { let current_password = serde_json::json!({ "current_password": password }); let new_password = "recovery-transport-new-password"; - // Production composition: the same application router serves V1 directly - // and V2 behind the gateway, each with the error-contract layer. - let application = crate::application_routes(Arc::clone(&app_state)) - .layer(axum::middleware::from_fn(crate::add_error_contract_header)); - let session_v1_id = uuid::Uuid::new_v4(); - let session_v1_key = crate::encrypt::generate_random::<32>(); - app_state - .store_session_state(session_v1_id, SessionState::new(session_v1_key)) - .await - .unwrap(); - let session_v2 = test_session(0xE1); + // Production composition: the application is served only behind the + // gateway, and the listener's own router exposes none of its routes. + let application = crate::transport_v2_application(Arc::clone(&app_state)); + let production_gateway = + TransportV2Gateway::new(Arc::clone(&app_state), application.clone()); + let listener_routes = crate::public_routes(Arc::clone(&app_state), &production_gateway); + let session = test_session(0xE1); let sessions = Arc::new(SessionStore::new(NonZeroUsize::new(2).unwrap())); - sessions.insert(Arc::clone(&session_v2.server)).unwrap(); + sessions.insert(Arc::clone(&session.server)).unwrap(); let gateway = request_router(application.clone(), sessions); let mut request_number = 0; - // Every recovery route rejects a valid V1 session generically, before - // enrollment, proof verification, or consumption. + // A plaintext request carrying a valid access token reaches no recovery + // route: the listener does not serve them, and the application itself + // refuses a request the gateway did not decrypt, before enrollment, proof + // verification, or consumption. let placeholder_code = serde_json::json!({ "proof": proof, "new_password": new_password, @@ -244,21 +189,29 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { ), (Method::POST, "/password-reset/v2/complete", Some(&placeholder_code)), ] { - let (status, body) = recovery_v1_request( + assert_eq!( + direct_application_request( + &listener_routes, + method.clone(), + target, + payload, + Some(&access_token), + ) + .await, + 404, + "{method} {target} must not be served outside the gateway" + ); + let refused = direct_application_request( &application, - session_v1_id, - &session_v1_key, method.clone(), target, payload, - &v1_token, + Some(&access_token), ) .await; - assert_eq!(status, 400, "{method} {target} must reject V1 sessions"); - assert_eq!( - body, - serde_json::json!({ "status": 400, "message": "Bad Request" }), - "{method} {target} V1 rejection must stay generic" + assert!( + matches!(refused, 400 | 401), + "{method} {target} must refuse a request the gateway did not decrypt, got {refused}" ); } assert!(app_state.db.get_recovery_wrap(user.uuid).unwrap().is_none()); @@ -273,15 +226,15 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { .unwrap() .is_some_and(|request| request.id == reset_request.id && !request.is_reset)); - // V2: status, enrollment, reset options, and preserving completion. - let (status, body) = recovery_v2_request( + // Through the gateway: status, enrollment, reset options, and preserving completion. + let (status, body) = recovery_request( &gateway, - &session_v2, + &session, &mut request_number, "GET", "/protected/recovery-code", None, - Some(&v2_token), + Some(&access_token), ) .await; assert_eq!(status, 200); @@ -295,36 +248,36 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { }) ); - let (status, body) = recovery_v2_request( + let (status, body) = recovery_request( &gateway, - &session_v2, + &session, &mut request_number, "POST", "/protected/recovery-code/enroll", Some(¤t_password), - Some(&v2_token), + Some(&access_token), ) .await; assert_eq!(status, 200); let recovery_code = body["recovery_code"].as_str().unwrap().to_string(); assert!(recovery_code.starts_with("MPLRC1-")); - let (status, body) = recovery_v2_request( + let (status, body) = recovery_request( &gateway, - &session_v2, + &session, &mut request_number, "GET", "/protected/recovery-code", None, - Some(&v2_token), + Some(&access_token), ) .await; assert_eq!(status, 200); assert_eq!(body["enrolled"], serde_json::json!(true)); - let (status, body) = recovery_v2_request( + let (status, body) = recovery_request( &gateway, - &session_v2, + &session, &mut request_number, "POST", "/password-reset/v2/options", @@ -338,9 +291,9 @@ async fn db_recovery_flow_v1_rejected_v2_completes() { serde_json::json!({ "recovery_enrolled": true, "destructive_reset_available": true }) ); - let (status, body) = recovery_v2_request( + let (status, body) = recovery_request( &gateway, - &session_v2, + &session, &mut request_number, "POST", "/password-reset/v2/complete", diff --git a/services/opensecret/src/web/attestation_routes.rs b/services/opensecret/src/web/attestation_routes.rs index ff4659b7d..46fb43e39 100644 --- a/services/opensecret/src/web/attestation_routes.rs +++ b/services/opensecret/src/web/attestation_routes.rs @@ -3,14 +3,12 @@ use aws_nitro_enclaves_nsm_api::{ api::{Request, Response}, driver::{nsm_exit, nsm_init, nsm_process_request}, }; -use axum::routing::post; use axum::{extract::State, routing::get, Json}; use axum::{http::StatusCode, Router}; use base64::{engine::general_purpose, Engine as _}; -use chacha20poly1305::{aead::Aead, ChaCha20Poly1305, Key, KeyInit, Nonce}; use chrono::{Duration, Utc}; use secp256k1::{PublicKey, Secp256k1, SecretKey}; -use serde::{Deserialize, Serialize}; +use serde::Serialize; use serde_bytes::ByteBuf; use serde_cbor::Value; use sha2::{Digest, Sha256}; @@ -18,72 +16,45 @@ use std::collections::BTreeMap; use std::sync::{Arc, LazyLock}; use tokio::{sync::Semaphore, task}; use tracing::error; -use uuid::Uuid; use yasna::models::ObjectIdentifier; use yasna::{construct_der, Tag}; -use zeroize::{Zeroize, ZeroizeOnDrop}; -#[derive(Zeroize, ZeroizeOnDrop)] -pub struct SessionState { - session_key: [u8; 32], -} - -impl SessionState { - pub fn new(session_key: [u8; 32]) -> Self { - Self { session_key } - } - - pub fn get_session_key(&self) -> &[u8; 32] { - &self.session_key - } - - pub fn decrypt(&self, encrypted_data: &[u8], nonce: &[u8; 12]) -> Result, ApiError> { - let key = Key::from_slice(self.session_key.as_ref()); - let cipher = ChaCha20Poly1305::new(key); - let nonce = Nonce::from_slice(nonce); - - cipher.decrypt(nonce, encrypted_data).map_err(|e| { - tracing::error!("could not decrypt data: {e}"); - ApiError::InternalServerError - }) - } -} - -#[derive(Deserialize)] -struct KeyExchangeRequest { - nonce: String, - client_public_key: String, -} - -#[derive(Serialize)] -struct KeyExchangeResponse { - session_id: Uuid, - encrypted_session_key: String, -} +const MAX_ATTESTATION_NONCE_BYTES: usize = 512; #[derive(Serialize)] struct AttestationResponse { attestation_document: String, } +/// The public attestation document. +/// +/// This is not a transport: it establishes no session and attests no key. It +/// lets anyone fetch a fresh document for a nonce they chose and inspect the +/// enclave's measurements, as the apps' verification page and deployment +/// checks do. A Transport V2 session carries its own attestation, bound to +/// its handshake, in the `POST /v2/session` response. pub fn router(app_state: Arc) -> Router<()> { Router::new() .route("/attestation/:nonce", get(get_attestation)) - .route("/key_exchange", post(key_exchange)) .with_state(app_state) } +fn validate_attestation_nonce(nonce: &str) -> Result<(), ApiError> { + if nonce.len() > MAX_ATTESTATION_NONCE_BYTES { + return Err(ApiError::BadRequest); + } + Ok(()) +} + async fn get_attestation( State(data): State>, axum::extract::Path(nonce): axum::extract::Path, ) -> Result<(StatusCode, Json), ApiError> { - // Create an ephemeral key pair for this request - let enclave_public_key = data.create_ephemeral_key(&nonce).await?; + validate_attestation_nonce(&nonce)?; - // Create a request for the attestation document let request = Request::Attestation { user_data: None, - public_key: Some(ByteBuf::from(enclave_public_key.as_bytes().to_vec())), + public_key: None, nonce: Some(ByteBuf::from(nonce.into_bytes())), }; @@ -400,97 +371,23 @@ fn generate_real_attestation_document(request: Request) -> Result, ApiEr } } -async fn key_exchange( - State(data): State>, - Json(payload): Json, -) -> Result, ApiError> { - let client_public_key_bytes = general_purpose::STANDARD - .decode(&payload.client_public_key) - .map_err(|_| ApiError::BadRequest)?; - - let client_public_key = x25519_dalek::PublicKey::from( - <[u8; 32]>::try_from(client_public_key_bytes.as_slice()) - .map_err(|_| ApiError::BadRequest)?, - ); - - let ephemeral_secret = data - .get_and_remove_ephemeral_secret(&payload.nonce) - .await? - .ok_or(ApiError::BadRequest)?; - - let shared_secret = derive_contributory_shared_secret(ephemeral_secret, &client_public_key)?; - - // Generate a random session key using your secure random function - let session_state = SessionState::new(crate::encrypt::generate_random()); - - // Encrypt the session key using the shared secret - let nonce_bytes: [u8; 12] = crate::encrypt::generate_random(); - let nonce = Nonce::from_slice(&nonce_bytes); - let cipher = ChaCha20Poly1305::new(shared_secret.as_bytes().into()); - let mut encrypted_session_key = nonce_bytes.to_vec(); - encrypted_session_key.extend_from_slice( - &cipher - .encrypt(nonce, session_state.get_session_key().as_ref()) - .map_err(|_| ApiError::InternalServerError)?, - ); - - // Generate a new UUID for the session - let session_id = Uuid::new_v4(); - - // Store the session state, evicting the least-recently-used unleased - // session if the cache is full. - data.store_session_state(session_id, session_state).await?; - Ok(Json(KeyExchangeResponse { - session_id, - encrypted_session_key: general_purpose::STANDARD.encode(&encrypted_session_key), - })) -} - -fn derive_contributory_shared_secret( - ephemeral_secret: x25519_dalek::EphemeralSecret, - client_public_key: &x25519_dalek::PublicKey, -) -> Result { - let shared_secret = ephemeral_secret.diffie_hellman(client_public_key); - if !shared_secret.was_contributory() { - return Err(ApiError::BadRequest); - } - - Ok(shared_secret) -} - #[cfg(test)] mod tests { use super::*; #[test] - fn session_state_zeroizes_key_material() { - fn assert_zeroize_on_drop() {} - - assert_zeroize_on_drop::(); - - let mut state = SessionState::new([0xA5; 32]); - state.zeroize(); - assert_eq!(state.get_session_key(), &[0; 32]); - } - - #[test] - fn key_exchange_rejects_non_contributory_x25519_public_key() { - let ephemeral_secret = x25519_dalek::EphemeralSecret::random_from_rng(rand_core::OsRng); - let low_order_public_key = x25519_dalek::PublicKey::from([0u8; 32]); - + fn nonce_limit_is_measured_in_bytes() { + assert!(validate_attestation_nonce(&"a".repeat(512)).is_ok()); assert!(matches!( - derive_contributory_shared_secret(ephemeral_secret, &low_order_public_key), + validate_attestation_nonce(&"a".repeat(513)), Err(ApiError::BadRequest) )); - } - #[test] - fn key_exchange_accepts_honest_x25519_public_key() { - let ephemeral_secret = x25519_dalek::EphemeralSecret::random_from_rng(rand_core::OsRng); - let client_secret = x25519_dalek::EphemeralSecret::random_from_rng(rand_core::OsRng); - let client_public_key = x25519_dalek::PublicKey::from(&client_secret); - - assert!(derive_contributory_shared_secret(ephemeral_secret, &client_public_key).is_ok()); + assert!(validate_attestation_nonce(&"é".repeat(256)).is_ok()); + assert!(matches!( + validate_attestation_nonce(&"é".repeat(257)), + Err(ApiError::BadRequest) + )); } #[tokio::test(flavor = "multi_thread", worker_threads = 4)] diff --git a/services/opensecret/src/web/encryption_middleware.rs b/services/opensecret/src/web/encryption_middleware.rs index 2a863181c..37aa0b667 100644 --- a/services/opensecret/src/web/encryption_middleware.rs +++ b/services/opensecret/src/web/encryption_middleware.rs @@ -1,30 +1,22 @@ use axum::{ - body::{Body, Bytes, HttpBody}, - extract::{FromRequestParts, State}, - http::{request::Parts, HeaderMap, Method, Request}, + body::Body, + extract::FromRequestParts, + http::{request::Parts, Request}, middleware::Next, response::{IntoResponse, Response}, - Json, }; -use base64::Engine; -use http_body::{Frame, SizeHint}; use serde::de::{DeserializeOwned, DeserializeSeed, IgnoredAny, MapAccess, SeqAccess, Visitor}; -use serde::{Deserialize, Serialize}; +use serde::Serialize; use std::fmt; -use std::future::Future; -use std::pin::Pin; -use std::sync::Arc; -use std::task::{Context, Poll}; -use uuid::Uuid; use crate::{transport_v2::crypto::SessionId, ApiError, AppState}; -const MAX_ENCRYPTED_BODY_BYTES: usize = 50 * 1024 * 1024; // 50MB +const MAX_LOGICAL_BODY_BYTES: usize = 50 * 1024 * 1024; // 50MB // Containers and scalar values each count as one node; object member names do // not count separately. String bytes are already covered by the body-size // limit and do not increase this count. -const MAX_V2_JSON_NODES: usize = 1_048_576; +const MAX_JSON_NODES: usize = 1_048_576; #[derive(Clone, Copy, Debug, Eq, PartialEq)] enum JsonComplexityError { @@ -149,7 +141,7 @@ fn validate_json_complexity(input: &[u8], max_nodes: usize) -> Result<(), JsonCo deserializer.end().map_err(|_| JsonComplexityError::Invalid) } -fn validate_v2_json_body(input: &[u8], max_nodes: usize) -> Result<(), ApiError> { +fn validate_json_body(input: &[u8], max_nodes: usize) -> Result<(), ApiError> { match validate_json_complexity(input, max_nodes) { Ok(()) => Ok(()), Err(JsonComplexityError::Invalid) => Err(ApiError::BadRequest), @@ -190,342 +182,87 @@ where request.extensions_mut().insert(decrypted); } -/// Identifies the transport context that must encrypt a handler response. +/// The attested Transport V2 session a request arrived on. /// -/// Keeping this distinct from the application's authenticated principal makes -/// the response transport explicit at the handler boundary. V1 contains only -/// the legacy session identifier; future protocol versions can carry their -/// exact response-encryption context without changing every handler again. +/// Only the Transport V2 gateway can attach this marker: it is an in-process +/// request extension, so an HTTP caller cannot fabricate one. Its presence is +/// the application's proof that the gateway authenticated and decrypted the +/// request, and that the gateway will encrypt the handler's response. #[derive(Clone, Debug, Eq, PartialEq)] pub struct TransportSession { - kind: TransportSessionKind, -} - -#[derive(Clone, Debug, Eq, PartialEq)] -enum TransportSessionKind { - V1 { - session_id: Uuid, - }, - #[allow(dead_code)] // Constructed by the stacked V2 gateway. - V2 { - session_id: SessionId, - }, + session_id: SessionId, } impl TransportSession { - // Widened `pub(crate)` only so sibling test modules can fabricate v1 - // markers for the recovery transport-gate tests. It remains an in-process - // capability: HTTP callers cannot create request extensions, and every - // recovery route rejects v1 markers at route-layer and handler level. - pub(crate) fn v1(session_id: Uuid) -> Self { - Self { - kind: TransportSessionKind::V1 { session_id }, - } - } - - /// Marks a request that has already been authenticated and decrypted by - /// the private Transport V2 gateway. This is an in-process capability: an - /// HTTP caller cannot create request extensions. - #[allow(dead_code)] // Constructed by the stacked V2 gateway. - pub(crate) fn v2(session_id: SessionId) -> Self { - Self { - kind: TransportSessionKind::V2 { session_id }, - } - } - - pub(crate) fn is_v2(&self) -> bool { - matches!(&self.kind, TransportSessionKind::V2 { .. }) - } - - #[allow(dead_code)] // Used by OAuth and native handoff in the gateway layer. - pub(crate) fn v2_session_id(&self) -> Option { - match &self.kind { - TransportSessionKind::V1 { .. } => None, - TransportSessionKind::V2 { session_id } => Some(*session_id), - } - } - - pub(crate) async fn encrypt_response_bytes( - &self, - state: &AppState, - plaintext: &[u8], - ) -> Result, ApiError> { - match &self.kind { - TransportSessionKind::V1 { session_id } => { - state.encrypt_session_data(session_id, plaintext).await - } - TransportSessionKind::V2 { .. } => Ok(plaintext.to_vec()), - } - } - - /// Returns the exact `data:` payload expected by the logical SSE stream. - /// V1 keeps its per-event encryption and base64 wrapper; V2 leaves the - /// inner stream as ordinary UTF-8 because the gateway encrypts the entire - /// response carrier record-by-record. - pub(crate) async fn encode_sse_data( - &self, - state: &AppState, - plaintext: &str, - ) -> Result { - match &self.kind { - TransportSessionKind::V1 { .. } => { - let encrypted = self - .encrypt_response_bytes(state, plaintext.as_bytes()) - .await?; - Ok(base64::engine::general_purpose::STANDARD.encode(encrypted)) - } - TransportSessionKind::V2 { .. } => Ok(plaintext.to_string()), - } + pub(crate) fn new(session_id: SessionId) -> Self { + Self { session_id } } -} - -#[derive(Deserialize)] -pub struct EncryptedRequest { - pub encrypted: String, -} -#[derive(Serialize)] -pub struct EncryptedResponse { - pub encrypted: String, - #[serde(skip)] - _phantom: std::marker::PhantomData, -} - -impl EncryptedResponse { - pub fn new(encrypted: String) -> Self { - Self { - encrypted, - _phantom: std::marker::PhantomData, - } + pub(crate) fn session_id(&self) -> SessionId { + self.session_id } } -fn skips_encrypted_body(method: &Method) -> bool { - method == Method::GET - || method == Method::DELETE - || std::any::TypeId::of::() == std::any::TypeId::of::<()>() -} - -/// Rejects a v1 transport session before the handler can run. +/// Parses the logical request body the Transport V2 gateway already decrypted. /// -/// Applied as a route layer on sub-routers whose routes are reachable only -/// through the v2 gateway. A missing `TransportSession` also fails: a request -/// that bypassed both transports never established transport security. -pub async fn require_transport_v2( - request: Request, - next: Next, -) -> Result { - if !request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2) - { - return Err(ApiError::BadRequest); - } - Ok(next.run(request).await) -} - -/// Handler-level defense-in-depth: the middleware gate rejects v1 sessions -/// before the handler, and this guard rejects them again inside the handler. -pub(crate) fn require_v2_transport_session(session: &TransportSession) -> Result<(), ApiError> { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } - Ok(()) -} - -fn parse_session_id(headers: &HeaderMap) -> Result { - headers - .get("x-session-id") - .and_then(|value| value.to_str().ok()) - .and_then(|value| Uuid::parse_str(value).ok()) - .ok_or(ApiError::BadRequest) -} - -async fn forward_bodyless_request( - session_check: SessionCheck, - session_id: Uuid, - mut request: Request, - run_next: RunNext, -) -> Result -where - T: 'static, - Resource: Send + Unpin + 'static, - SessionCheck: Future>, - RunNext: FnOnce(Request) -> RunNextFuture, - RunNextFuture: Future, -{ - let resource = session_check.await?; - - if std::any::TypeId::of::() == std::any::TypeId::of::<()>() { - request.extensions_mut().insert(()); - } - request - .extensions_mut() - .insert(TransportSession::v1(session_id)); - let response = run_next(request).await; - Ok(hold_resource_through_response_body(response, resource)) -} - +/// Fails closed for a request that did not come through the gateway: without +/// its `TransportSession` marker no transport security was established, so no +/// handler may run. pub async fn decrypt_request( - State(state): State>, - headers: HeaderMap, mut request: Request, next: Next, ) -> Result where T: DeserializeOwned + Send + Sync + Clone + 'static, { - if request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2) - { - if std::any::TypeId::of::() == std::any::TypeId::of::<()>() { - request.extensions_mut().insert(()); - } else { - let body = std::mem::replace(request.body_mut(), Body::empty()); - let body_bytes = axum::body::to_bytes(body, MAX_ENCRYPTED_BODY_BYTES) - .await - .map_err(|_| ApiError::PayloadTooLarge)?; - validate_v2_json_body(&body_bytes, MAX_V2_JSON_NODES)?; - let decoded = - serde_json::from_slice::(&body_bytes).map_err(|_| ApiError::BadRequest)?; - store_decrypted(&mut request, decoded); - } - - return Ok(next.run(request).await); - } - - let session_id = parse_session_id(&headers)?; - - // Skip body processing for GET, DELETE, or when T is (). - if skips_encrypted_body::(request.method()) { - // Bodyless requests cannot prove possession by decrypting a payload. - // Reject an unknown session before a handler can perform side effects. - return forward_bodyless_request::( - async { - let session_lease = state.acquire_request_session(&session_id).await?; - state.touch_session(&session_id).await?; - Ok(session_lease) - }, - session_id, - request, - move |request| next.run(request), - ) - .await; - } - - let body = std::mem::replace(request.body_mut(), Body::empty()); - let body_bytes = axum::body::to_bytes(body, MAX_ENCRYPTED_BODY_BYTES) - .await - .map_err(|_| ApiError::PayloadTooLarge)?; - - let encrypted_request: EncryptedRequest = - serde_json::from_slice(&body_bytes).map_err(|_| ApiError::BadRequest)?; - - // Pin only after the request body has arrived. A slow or abandoned - // upload therefore cannot retain a session indefinitely. - let session_lease = state.acquire_request_session(&session_id).await?; - let decrypted_data = state - .decrypt_session_data(&session_id, &session_lease, &encrypted_request.encrypted) - .await - .map_err(|_| ApiError::BadRequest)?; - - let decrypted: T = serde_json::from_slice(&decrypted_data).map_err(|e| { - tracing::error!( - "Failed to deserialize decrypted data: {}", - crate::log_redaction::JsonErrorSummary(&e) - ); - ApiError::BadRequest - })?; - - store_decrypted(&mut request, decrypted); - request - .extensions_mut() - .insert(TransportSession::v1(session_id)); - let response = next.run(request).await; - Ok(hold_resource_through_response_body(response, session_lease)) -} - -fn hold_resource_through_response_body(mut response: Response, resource: T) -> Response -where - T: Send + Unpin + 'static, -{ - let body = std::mem::replace(response.body_mut(), Body::empty()); - *response.body_mut() = Body::new(ResourceBody { - inner: body, - _resource: resource, - }); - response -} - -struct ResourceBody { - inner: Body, - _resource: T, -} - -impl HttpBody for ResourceBody -where - T: Send + Unpin + 'static, -{ - type Data = Bytes; - type Error = axum::Error; - - fn poll_frame( - self: Pin<&mut Self>, - context: &mut Context<'_>, - ) -> Poll, Self::Error>>> { - Pin::new(&mut self.get_mut().inner).poll_frame(context) + if request.extensions().get::().is_none() { + return Err(ApiError::BadRequest); } - fn is_end_stream(&self) -> bool { - self.inner.is_end_stream() + if std::any::TypeId::of::() == std::any::TypeId::of::<()>() { + request.extensions_mut().insert(()); + } else { + let body = std::mem::replace(request.body_mut(), Body::empty()); + let body_bytes = axum::body::to_bytes(body, MAX_LOGICAL_BODY_BYTES) + .await + .map_err(|_| ApiError::PayloadTooLarge)?; + validate_json_body(&body_bytes, MAX_JSON_NODES)?; + let decoded = serde_json::from_slice::(&body_bytes).map_err(|_| ApiError::BadRequest)?; + store_decrypted(&mut request, decoded); } - fn size_hint(&self) -> SizeHint { - self.inner.size_hint() - } + Ok(next.run(request).await) } +/// Serializes a handler's logical JSON response. The Transport V2 gateway +/// encrypts the whole response carrier, so the body leaves the handler as +/// ordinary JSON. pub async fn encrypt_response( - state: &AppState, - transport_session: &TransportSession, + _state: &AppState, + _transport_session: &TransportSession, response: &T, ) -> Result { let response_json = serde_json::to_vec(response).map_err(|_| ApiError::InternalServerError)?; - - if transport_session.is_v2() { - return Ok(( - [(axum::http::header::CONTENT_TYPE, "application/json")], - response_json, - ) - .into_response()); - } - - let encrypted_response = transport_session - .encrypt_response_bytes(state, &response_json) - .await?; - Ok(Json(EncryptedResponse::::new( - base64::engine::general_purpose::STANDARD.encode(encrypted_response), - )) - .into_response()) + Ok(( + [(axum::http::header::CONTENT_TYPE, "application/json")], + response_json, + ) + .into_response()) } #[cfg(test)] mod tests { use super::*; - use crate::lease_aware_cache::{InsertError, LeaseAwareTtlCache}; use axum::{ - http::{HeaderMap, HeaderValue}, - response::IntoResponse, + http::{Method, StatusCode}, + middleware::from_fn, + routing::post, + Extension, Router, }; - use std::convert::Infallible; - use std::future::{poll_fn, ready}; - use std::io; - use std::num::NonZeroUsize; + use serde::Deserialize; use std::sync::atomic::{AtomicUsize, Ordering}; - use std::time::Duration; + use std::sync::Arc; + use tower::ServiceExt; #[derive(Debug)] struct CloneSpy { @@ -591,268 +328,126 @@ mod tests { } #[test] - fn v2_json_preflight_distinguishes_invalid_json_from_excess_structure() { + fn json_preflight_distinguishes_invalid_json_from_excess_structure() { assert!(matches!( - validate_v2_json_body(br#"[1,]"#, 16), + validate_json_body(br#"[1,]"#, 16), Err(ApiError::BadRequest) )); assert!(matches!( - validate_v2_json_body(br#"[1,2]"#, 2), + validate_json_body(br#"[1,2]"#, 2), Err(ApiError::PayloadTooLarge) )); - assert!(validate_v2_json_body(br#"[1,2]"#, 3).is_ok()); + assert!(validate_json_body(br#"[1,2]"#, 3).is_ok()); } - #[test] - fn classifies_every_bodyless_disjunct() { - assert!(skips_encrypted_body::(&Method::GET)); - assert!(skips_encrypted_body::(&Method::DELETE)); - assert!(skips_encrypted_body::<()>(&Method::POST)); - assert!(!skips_encrypted_body::(&Method::POST)); + #[derive(Clone, Deserialize)] + struct Echo { + value: String, } - #[test] - fn missing_and_malformed_session_headers_are_generic_bad_requests() { - for headers in [HeaderMap::new(), { - let mut headers = HeaderMap::new(); - headers.insert("x-session-id", HeaderValue::from_static("not-a-uuid")); - headers - }] { - let error = parse_session_id(&headers).unwrap_err(); - let response = error.into_response(); - assert_eq!(response.status(), axum::http::StatusCode::BAD_REQUEST); - assert!(response.headers().get(crate::ERROR_CODE_HEADER).is_none()); + fn counting_router(calls: Arc) -> Router<()> { + Router::new() + .route( + "/echo", + post({ + let calls = Arc::clone(&calls); + move |Decrypted(body): Decrypted, + Extension(_session): Extension| { + let calls = Arc::clone(&calls); + async move { + calls.fetch_add(1, Ordering::SeqCst); + body.value + } + } + }) + .layer(from_fn(decrypt_request::)), + ) + .route( + "/bodyless", + post({ + let calls = Arc::clone(&calls); + move |Decrypted(()): Decrypted<()>| { + let calls = Arc::clone(&calls); + async move { + calls.fetch_add(1, Ordering::SeqCst); + StatusCode::NO_CONTENT + } + } + }) + .layer(from_fn(decrypt_request::<()>)), + ) + } + + fn request( + target: &str, + body: &'static str, + session: Option, + ) -> Request { + let mut request = Request::builder() + .method(Method::POST) + .uri(target) + .body(Body::from(body)) + .unwrap(); + if let Some(session) = session { + request.extensions_mut().insert(session); } + request } - #[tokio::test] - async fn failed_session_check_never_calls_next() { - let calls = Arc::new(AtomicUsize::new(0)); - let observed_calls = calls.clone(); - - let result = forward_bodyless_request::<(), _, _, _, _>( - ready(Err::<(), ApiError>(ApiError::SessionNotFound)), - Uuid::new_v4(), - Request::builder() - .method(Method::POST) - .body(Body::empty()) - .unwrap(), - move |_| { - observed_calls.fetch_add(1, Ordering::SeqCst); - async { Response::new(Body::empty()) } - }, - ) - .await; - - assert_eq!(calls.load(Ordering::SeqCst), 0); - let error = match result { - Err(error) => error, - Ok(_) => panic!("unknown session reached next"), - }; - let response = error.into_response(); - assert_eq!(response.status(), axum::http::StatusCode::BAD_REQUEST); - assert_eq!( - response.headers().get(crate::ERROR_CODE_HEADER).unwrap(), - "session_not_found" - ); - let body = axum::body::to_bytes(response.into_body(), 1024) - .await - .unwrap(); - assert_eq!(body.as_ref(), br#"{"status":400,"message":"Bad Request"}"#); + fn gateway_session() -> TransportSession { + TransportSession::new(SessionId::from_bytes([7; 16])) } #[tokio::test] - async fn successful_session_check_calls_next_once_with_extensions() { - let session_id = Uuid::new_v4(); + async fn request_without_a_gateway_session_never_reaches_a_handler() { let calls = Arc::new(AtomicUsize::new(0)); - let observed_calls = calls.clone(); - - forward_bodyless_request::<(), _, _, _, _>( - ready(Ok::<(), ApiError>(())), - session_id, - Request::builder() - .method(Method::POST) - .body(Body::empty()) - .unwrap(), - move |request| { - assert_eq!( - request.extensions().get::(), - Some(&TransportSession::v1(session_id)) - ); - assert!(request.extensions().get::<()>().is_some()); - observed_calls.fetch_add(1, Ordering::SeqCst); - async { Response::new(Body::empty()) } - }, - ) - .await - .unwrap(); - - assert_eq!(calls.load(Ordering::SeqCst), 1); - } - - struct DropSpy(Arc); + let router = counting_router(Arc::clone(&calls)); - impl Drop for DropSpy { - fn drop(&mut self) { - self.0.fetch_add(1, Ordering::SeqCst); + for (target, body) in [("/echo", r#"{"value":"hello"}"#), ("/bodyless", "")] { + let response = router + .clone() + .oneshot(request(target, body, None)) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::BAD_REQUEST, "{target}"); + assert!(response.headers().get(crate::ERROR_CODE_HEADER).is_none()); } - } - - #[test] - fn unpolled_response_holds_resource_until_body_drop() { - let drops = Arc::new(AtomicUsize::new(0)); - let response = Response::new(Body::from("encrypted response")); - let response = hold_resource_through_response_body(response, DropSpy(drops.clone())); - - assert_eq!(drops.load(Ordering::SeqCst), 0); - drop(response); - assert_eq!(drops.load(Ordering::SeqCst), 1); - } - - #[test] - fn streaming_response_lease_blocks_eviction_until_body_drop() { - let mut cache = - LeaseAwareTtlCache::new(NonZeroUsize::new(1).unwrap(), Duration::from_secs(60)); - cache.insert_evicting(1, "active stream").unwrap(); - let lease = cache.acquire(&1).unwrap(); - - let stream = futures::stream::pending::>(); - let response = Response::new(Body::from_stream(stream)); - let response = hold_resource_through_response_body(response, lease); - - assert_eq!( - cache.insert_evicting(2, "new session"), - Err(InsertError::AllEntriesLeased) - ); - drop(response); - assert!(cache.insert_evicting(2, "new session").is_ok()); + assert_eq!(calls.load(Ordering::SeqCst), 0); } #[tokio::test] - async fn wrapped_body_preserves_payload_and_exact_size_hint() { - let drops = Arc::new(AtomicUsize::new(0)); - let response = Response::new(Body::from("encrypted response")); - let response = hold_resource_through_response_body(response, DropSpy(drops.clone())); - - assert_eq!(response.body().size_hint().exact(), Some(18)); - let bytes = axum::body::to_bytes(response.into_body(), 1024) + async fn gateway_request_body_is_parsed_once_for_its_handler() { + let calls = Arc::new(AtomicUsize::new(0)); + let router = counting_router(Arc::clone(&calls)); + + let response = router + .clone() + .oneshot(request( + "/echo", + r#"{"value":"hello"}"#, + Some(gateway_session()), + )) .await .unwrap(); - assert_eq!(&bytes[..], b"encrypted response"); - assert_eq!(drops.load(Ordering::SeqCst), 1); - } - - struct DataThenTrailersBody { - next_frame: u8, - } - - impl HttpBody for DataThenTrailersBody { - type Data = Bytes; - type Error = Infallible; - - fn poll_frame( - mut self: Pin<&mut Self>, - _context: &mut Context<'_>, - ) -> Poll, Self::Error>>> { - let frame = match self.next_frame { - 0 => Some(Frame::data(Bytes::from_static(b"x"))), - 1 => { - let mut trailers = HeaderMap::new(); - trailers.insert("x-test-trailer", HeaderValue::from_static("preserved")); - Some(Frame::trailers(trailers)) - } - _ => None, - }; - self.next_frame += 1; - Poll::Ready(frame.map(Ok)) - } - - fn is_end_stream(&self) -> bool { - self.next_frame > 1 - } - - fn size_hint(&self) -> SizeHint { - SizeHint::with_exact(1) - } - } - - #[tokio::test] - async fn wrapped_body_preserves_trailers_and_lease_through_end_of_stream() { - let drops = Arc::new(AtomicUsize::new(0)); - let response = Response::new(Body::new(DataThenTrailersBody { next_frame: 0 })); - let response = hold_resource_through_response_body(response, DropSpy(drops.clone())); - let mut body = Box::pin(response.into_body()); - - let data = poll_fn(|context| body.as_mut().poll_frame(context)) + assert_eq!(response.status(), StatusCode::OK); + let body = axum::body::to_bytes(response.into_body(), 1024) .await - .unwrap() - .unwrap() - .into_data() .unwrap(); - assert_eq!(&data[..], b"x"); + assert_eq!(&body[..], b"hello"); - let trailers = poll_fn(|context| body.as_mut().poll_frame(context)) + let response = router + .clone() + .oneshot(request("/bodyless", "", Some(gateway_session()))) .await - .unwrap() - .unwrap() - .into_trailers() .unwrap(); - assert_eq!(trailers["x-test-trailer"], "preserved"); - assert!(poll_fn(|context| body.as_mut().poll_frame(context)) - .await - .is_none()); - assert!(body.is_end_stream()); - assert_eq!(drops.load(Ordering::SeqCst), 0); - - drop(body); - assert_eq!(drops.load(Ordering::SeqCst), 1); - } - - struct DataThenErrorBody { - next_frame: u8, - } + assert_eq!(response.status(), StatusCode::NO_CONTENT); + assert_eq!(calls.load(Ordering::SeqCst), 2); - impl HttpBody for DataThenErrorBody { - type Data = Bytes; - type Error = io::Error; - - fn poll_frame( - mut self: Pin<&mut Self>, - _context: &mut Context<'_>, - ) -> Poll, Self::Error>>> { - let frame = match self.next_frame { - 0 => Some(Ok(Frame::data(Bytes::from_static(b"x")))), - 1 => Some(Err(io::Error::other("test body failure"))), - _ => None, - }; - self.next_frame += 1; - Poll::Ready(frame) - } - } - - #[tokio::test] - async fn wrapped_body_preserves_errors_and_resource_until_drop() { - let drops = Arc::new(AtomicUsize::new(0)); - let response = Response::new(Body::new(DataThenErrorBody { next_frame: 0 })); - let response = hold_resource_through_response_body(response, DropSpy(drops.clone())); - let mut body = Box::pin(response.into_body()); - - let data = poll_fn(|context| body.as_mut().poll_frame(context)) + let response = router + .oneshot(request("/echo", "not json", Some(gateway_session()))) .await - .unwrap() - .unwrap() - .into_data() .unwrap(); - assert_eq!(&data[..], b"x"); - - let error = poll_fn(|context| body.as_mut().poll_frame(context)) - .await - .unwrap() - .unwrap_err(); - assert!(error.to_string().contains("test body failure")); - assert_eq!(drops.load(Ordering::SeqCst), 0); - - drop(body); - assert_eq!(drops.load(Ordering::SeqCst), 1); + assert_eq!(response.status(), StatusCode::BAD_REQUEST); + assert_eq!(calls.load(Ordering::SeqCst), 2); } } diff --git a/services/opensecret/src/web/login_routes.rs b/services/opensecret/src/web/login_routes.rs index 766654b39..84f251b65 100644 --- a/services/opensecret/src/web/login_routes.rs +++ b/services/opensecret/src/web/login_routes.rs @@ -1,4 +1,5 @@ use crate::transport_v2::envelope::{Credential, CredentialKind}; +use crate::web::encryption_middleware::TransportSession; use crate::web::password_policy::validate_password; use crate::User; use crate::{ @@ -7,12 +8,8 @@ use crate::{ jwt::{validate_token, AuthContext, NewToken, TokenType}, models::email_verification::NewEmailVerification, }; -use crate::{jwt::USER_REFRESH, web::encryption_middleware::TransportSession}; use crate::{ - web::encryption_middleware::{ - decrypt_request, encrypt_response, require_transport_v2, require_v2_transport_session, - Decrypted, - }, + web::encryption_middleware::{decrypt_request, encrypt_response, Decrypted}, Error, }; use crate::{ApiError, AppState}; @@ -159,10 +156,7 @@ pub fn router(app_state: Arc) -> Router<()> { ) .route( "/refresh", - post(refresh_token).layer(from_fn_with_state( - app_state.clone(), - prepare_refresh_request, - )), + post(refresh_token).layer(from_fn(prepare_refresh_request)), ) .route( "/verify-email/:code", @@ -182,17 +176,11 @@ pub fn router(app_state: Arc) -> Router<()> { decrypt_request::, )), ) - // The v2 options sub-router keeps its own v2-transport gate, merged in - // after the legacy defenses so only v2 reset routes require it. .merge(password_reset_v2_router(app_state.clone())) .with_state(app_state) } -/// The transport-v2 password-reset options sub-router. -/// -/// Layer ordering within this sub-router places `require_transport_v2` -/// outermost, so legacy v1 transport sessions are rejected before any request -/// body is decrypted or reset proof is verified. The state is intentionally +/// The recovery-aware password-reset sub-router. The state is intentionally /// kept so `router()` erases it once with `.with_state`. fn password_reset_v2_router(app_state: Arc) -> Router> { Router::new() @@ -210,7 +198,6 @@ fn password_reset_v2_router(app_state: Arc) -> Router> { decrypt_request::, )), ) - .route_layer(from_fn(require_transport_v2)) } #[derive(Serialize)] @@ -240,33 +227,27 @@ pub struct RefreshResponse { refresh_token: String, } +/// Takes the refresh token from the request envelope's resumption credential. +/// A refresh request has no logical body. async fn prepare_refresh_request( - State(state): State>, mut request: Request, next: Next, ) -> Result { - let is_transport_v2 = request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - if is_transport_v2 { - if request.body().size_hint().exact() != Some(0) { - return Err(ApiError::BadRequest); - } - let refresh_token = request - .extensions() - .get::() - .filter(|credential| credential.kind() == CredentialKind::Resumption) - .map(|credential| credential.value().to_string()) - .ok_or(ApiError::InvalidJwt)?; - request - .extensions_mut() - .insert(RefreshRequest { refresh_token }); - return Ok(next.run(request).await); + if request.extensions().get::().is_none() + || request.body().size_hint().exact() != Some(0) + { + return Err(ApiError::BadRequest); } - - let headers = request.headers().clone(); - decrypt_request::(State(state), headers, request, next).await + let refresh_token = request + .extensions() + .get::() + .filter(|credential| credential.kind() == CredentialKind::Resumption) + .map(|credential| credential.value().to_string()) + .ok_or(ApiError::InvalidJwt)?; + request + .extensions_mut() + .insert(RefreshRequest { refresh_token }); + Ok(next.run(request).await) } #[derive(Deserialize, Clone)] @@ -279,16 +260,12 @@ pub async fn login( Decrypted(creds): Decrypted, Extension(session_id): Extension, ) -> Result { - let auth_response = login_internal(data.clone(), creds, session_id.is_v2()).await?; + let auth_response = login_internal(data.clone(), creds).await?; let result = encrypt_response(&data, &session_id, &auth_response).await; result } -async fn login_internal( - data: Arc, - creds: Credentials, - is_transport_v2: bool, -) -> Result { +async fn login_internal(data: Arc, creds: Credentials) -> Result { // First get the project by client_id and verify it's active let project = data .db @@ -356,13 +333,13 @@ async fn login_internal( Ok(Some(authenticated_user)) => { let access_token = NewToken::new_with_auth_context( &authenticated_user.user, - TokenType::access_for_transport(is_transport_v2), + TokenType::TransportV2Access, &data, &authenticated_user.auth_context, )?; let refresh_token = NewToken::new_with_auth_context( &authenticated_user.user, - TokenType::refresh_for_transport(is_transport_v2), + TokenType::TransportV2Refresh, &data, &authenticated_user.auth_context, )?; @@ -431,7 +408,6 @@ pub async fn register( password: creds.password, client_id: creds.client_id, }, - session_id.is_v2(), ) .await?; @@ -494,12 +470,11 @@ pub async fn refresh_token( ) -> Result { info!("Refresh token request received"); - let refresh_audience = if session_id.is_v2() { - crate::jwt::TRANSPORT_V2_USER_REFRESH - } else { - USER_REFRESH - }; - let claims = validate_token(&refresh_request.refresh_token, &data, refresh_audience)?; + let claims = validate_token( + &refresh_request.refresh_token, + &data, + crate::jwt::TRANSPORT_V2_USER_REFRESH, + )?; // Audience check is now handled by validate_token let user_id = Uuid::parse_str(&claims.sub).map_err(|_| ApiError::InvalidJwt)?; @@ -513,15 +488,11 @@ pub async fn refresh_token( data.verify_seed_wrap_for_auth_context(&user, &auth_context) .map_err(|_| ApiError::InvalidJwt)?; - let new_access_token = NewToken::new_with_auth_context( - &user, - TokenType::access_for_transport(session_id.is_v2()), - &data, - &auth_context, - )?; + let new_access_token = + NewToken::new_with_auth_context(&user, TokenType::TransportV2Access, &data, &auth_context)?; let new_refresh_token = NewToken::new_with_auth_context( &user, - TokenType::refresh_for_transport(session_id.is_v2()), + TokenType::TransportV2Refresh, &data, &auth_context, )?; @@ -720,7 +691,7 @@ fn map_reset_proof_error(e: Error) -> ApiError { } } -/// Transport-v2 password reset options. +/// Recovery-aware password reset options. /// /// Verifies the existing email reset proof — the same proof legacy /// `/password-reset/confirm` verifies, mapped onto one sanitized error — and @@ -733,11 +704,6 @@ pub async fn password_reset_v2_options( Extension(transport_session): Extension, Decrypted(request): Decrypted, ) -> Result { - // Defense-in-depth: the sub-router middleware already rejected non-v2 - // transports before decryption; this guard keeps the handler - // self-sufficient if it is ever reachable from a mis-wired router. - require_v2_transport_session(&transport_session)?; - // The project client id scopes the email to exactly one account space. let project = data .db @@ -786,7 +752,7 @@ fn map_preserving_completion_error(e: Error) -> ApiError { } } -/// Transport-v2 password reset completion. +/// Recovery-aware password reset completion. /// /// Re-verifies the existing email reset proof — the same read-only proof the /// options route verifies — and then performs the requested completion: @@ -809,11 +775,6 @@ pub async fn password_reset_v2_complete( Extension(transport_session): Extension, Decrypted(request): Decrypted, ) -> Result { - // Defense-in-depth: the sub-router middleware already rejected non-v2 - // transports before decryption; this guard keeps the handler - // self-sufficient if it is ever reachable from a mis-wired router. - require_v2_transport_session(&transport_session)?; - // Reject invalid new passwords before verifying or consuming the reset proof. validate_password(&request.new_password)?; @@ -881,13 +842,13 @@ pub async fn password_reset_v2_complete( // transport the completion arrived on. let access_token = NewToken::new_with_auth_context( &user, - TokenType::access_for_transport(transport_session.is_v2()), + TokenType::TransportV2Access, &data, &new_auth_context, )?; let refresh_token = NewToken::new_with_auth_context( &user, - TokenType::refresh_for_transport(transport_session.is_v2()), + TokenType::TransportV2Refresh, &data, &new_auth_context, )?; diff --git a/services/opensecret/src/web/native_handoff_routes.rs b/services/opensecret/src/web/native_handoff_routes.rs index f1680bd47..6e5d97d9f 100644 --- a/services/opensecret/src/web/native_handoff_routes.rs +++ b/services/opensecret/src/web/native_handoff_routes.rs @@ -72,9 +72,6 @@ async fn create_native_handoff_grant( Extension(auth_context): Extension, Decrypted(request): Decrypted, ) -> Result { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } let target_session_id = SessionId::from_str(&request.native_session_id).map_err(|_| ApiError::BadRequest)?; let mut issued = issue_native_handoff_grant( @@ -107,7 +104,7 @@ async fn redeem_native_handoff( cache_root: Option>, Decrypted(request): Decrypted, ) -> Result { - let session_id = session.v2_session_id().ok_or(ApiError::BadRequest)?; + let session_id = session.session_id(); if credential.is_some() || cache_root.is_some() { return Err(ApiError::BadRequest); } diff --git a/services/opensecret/src/web/oauth_routes.rs b/services/opensecret/src/web/oauth_routes.rs index 7f2492328..1a4b60e87 100644 --- a/services/opensecret/src/web/oauth_routes.rs +++ b/services/opensecret/src/web/oauth_routes.rs @@ -521,43 +521,34 @@ pub async fn initiate_oauth( ApiError::InternalServerError })?; - // V2 adds a provider-verified authorization-code binding. V1 deliberately - // retains its existing authorization URL and state behavior. - let v2_session_id = session_id.v2_session_id(); - let (initial_url, csrf_token, code_binding) = if v2_session_id.is_some() { - let authorization = match provider_name { - "github" => { - oauth_provider - .as_github() - .ok_or(ApiError::InternalServerError)? - .generate_bound_authorize_url(&oauth_client) - .await - } - "google" => { - oauth_provider - .as_google() - .ok_or(ApiError::InternalServerError)? - .generate_bound_authorize_url(&oauth_client) - .await - } - "apple" => { - oauth_provider - .as_apple() - .ok_or(ApiError::InternalServerError)? - .generate_bound_authorize_url(&oauth_client) - .await - } - _ => return Err(ApiError::InternalServerError), - }; - ( - authorization.auth_url, - authorization.csrf_token, - Some(authorization.code_binding), - ) - } else { - let (auth_url, csrf_token) = oauth_provider.generate_authorize_url(&oauth_client).await; - (auth_url, csrf_token, None) + // Every authorization carries a provider-verified authorization-code + // binding to the transport session that initiated it. + let authorization = match provider_name { + "github" => { + oauth_provider + .as_github() + .ok_or(ApiError::InternalServerError)? + .generate_bound_authorize_url(&oauth_client) + .await + } + "google" => { + oauth_provider + .as_google() + .ok_or(ApiError::InternalServerError)? + .generate_bound_authorize_url(&oauth_client) + .await + } + "apple" => { + oauth_provider + .as_apple() + .ok_or(ApiError::InternalServerError)? + .generate_bound_authorize_url(&oauth_client) + .await + } + _ => return Err(ApiError::InternalServerError), }; + let initial_url = authorization.auth_url; + let csrf_token = authorization.csrf_token; // Snapshot the actual callback even when the caller omitted redirect_url. // Callbacks must not pick up a subsequently changed project default. @@ -572,25 +563,15 @@ pub async fn initiate_oauth( }; // Store the complete state in the provider - match (v2_session_id, code_binding) { - (Some(session_id), Some(code_binding)) => { - oauth_provider - .store_state_for_session( - csrf_token.secret(), - state.clone(), - session_id, - code_binding, - ) - .await - } - (None, None) => { - oauth_provider - .store_state(csrf_token.secret(), state.clone()) - .await - } - _ => return Err(ApiError::InternalServerError), - } - .map_err(|_| ApiError::TooManyRequests)?; + oauth_provider + .store_state_for_session( + csrf_token.secret(), + state.clone(), + session_id.session_id(), + authorization.code_binding, + ) + .await + .map_err(|_| ApiError::TooManyRequests)?; let state_json = serde_json::to_string(&state).map_err(|_| ApiError::InternalServerError)?; let state_base64 = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(state_json); @@ -645,26 +626,17 @@ pub async fn oauth_callback( // Validate and atomically consume the complete state so a successful match is one-time. // A mismatched state is left in the store for the legitimate callback. - let is_transport_v2 = session_id.is_v2(); - let code_binding = match session_id.v2_session_id() { - Some(session_id) => oauth_provider - .consume_state_for_session(&state, session_id) - .await - .map(Some), - None => oauth_provider.consume_state(&state).await.then_some(None), - }; - - let Some(code_binding) = code_binding else { + let Some(code_binding) = oauth_provider + .consume_state_for_session(&state, session_id.session_id()) + .await + else { error!("Invalid state in {} callback", provider_name); return Err(ApiError::BadRequest); }; - let (pkce_verifier, apple_nonce) = match (is_transport_v2, provider_name, code_binding) { - (false, _, None) => (None, None), - (true, "github" | "google", Some(OAuthCodeBinding::Pkce(verifier))) => { - (Some(verifier), None) - } - (true, "apple", Some(OAuthCodeBinding::AppleNonce(nonce))) => (None, Some(nonce)), + let (pkce_verifier, apple_nonce) = match (provider_name, code_binding) { + ("github" | "google", OAuthCodeBinding::Pkce(verifier)) => (Some(verifier), None), + ("apple", OAuthCodeBinding::AppleNonce(nonce)) => (None, Some(nonce)), _ => return Err(ApiError::InternalServerError), }; @@ -1063,8 +1035,7 @@ pub async fn oauth_callback( } }; - let auth_response = - oauth_callback_response(&app_state, &authenticated_user, session_id.is_v2())?; + let auth_response = oauth_callback_response(&app_state, &authenticated_user)?; encrypt_response(&app_state, &session_id, &auth_response).await } @@ -1214,8 +1185,8 @@ async fn fetch_apple_user( ) -> Result { debug!("Parsing and validating Apple ID token"); - // V2 requires the provider-signed ID token to carry the nonce generated - // for this exact state and session. V1 continues without nonce validation. + // A redirect callback passes the nonce generated for its exact state and + // session; the provider-signed ID token must carry it. let claims = validate_apple_native_token( &app_state.apple_jwt_verifier, id_token, @@ -1270,11 +1241,10 @@ fn authenticated_oauth_user( fn oauth_callback_response( app_state: &AppState, authenticated_user: &AuthenticatedOAuthUser, - is_transport_v2: bool, ) -> Result { let access_token = NewToken::new_with_auth_context( &authenticated_user.user, - TokenType::access_for_transport(is_transport_v2), + TokenType::TransportV2Access, app_state, &authenticated_user.auth_context, ) @@ -1284,7 +1254,7 @@ fn oauth_callback_response( })?; let refresh_token = NewToken::new_with_auth_context( &authenticated_user.user, - TokenType::refresh_for_transport(is_transport_v2), + TokenType::TransportV2Refresh, app_state, &authenticated_user.auth_context, ) @@ -1524,8 +1494,7 @@ pub async fn handle_apple_native_signin( let authenticated_user = authenticated_oauth_user(&app_state, user, "apple", &verified_user_id)?; - let auth_response = - oauth_callback_response(&app_state, &authenticated_user, session_id.is_v2())?; + let auth_response = oauth_callback_response(&app_state, &authenticated_user)?; debug!("Apple sign-in successful for existing user"); return encrypt_response(&app_state, &session_id, &auth_response).await; @@ -1590,8 +1559,7 @@ pub async fn handle_apple_native_signin( ) .await?; - let auth_response = - oauth_callback_response(&app_state, &authenticated_user, session_id.is_v2())?; + let auth_response = oauth_callback_response(&app_state, &authenticated_user)?; debug!("Apple native sign-in successful for new user"); encrypt_response(&app_state, &session_id, &auth_response).await diff --git a/services/opensecret/src/web/openai.rs b/services/opensecret/src/web/openai.rs index 2ceefc4e5..6efbabf8c 100644 --- a/services/opensecret/src/web/openai.rs +++ b/services/opensecret/src/web/openai.rs @@ -16,8 +16,7 @@ use crate::model_config::{ use crate::models::token_usage::NewTokenUsage; use crate::models::users::User; use crate::provider_cache::{ - derive_provider_cache_namespaces, legacy_continuum_cache_salt, legacy_maple_user_cache_secret, - CacheNamespaceRoot, DerivedCacheNamespaces, + derive_provider_cache_namespaces, CacheNamespaceRoot, DerivedCacheNamespaces, }; use crate::provider_client::{ ProviderClient, ProviderRequest, ProviderRequestError, ProviderResponse, ProviderSendTrace, @@ -55,13 +54,11 @@ use axum::{ routing::{get, post}, Router, }; -use base64::{engine::general_purpose, Engine as _}; use bigdecimal::BigDecimal; use chrono::Utc; use futures::StreamExt; use reqwest::Method; use serde_json::{json, Value}; -use sha2::{Digest, Sha256}; use std::collections::HashSet; use std::str::FromStr; use std::sync::{Arc, Mutex, OnceLock}; @@ -88,34 +85,23 @@ const MAX_BOUNDED_PROVIDER_RESPONSE_BYTES: usize = 256 * 1024; const PROVIDER_MANAGED_CACHE_SALT_FIELD: &str = "cache_salt"; const PROVIDER_MANAGED_USER_CACHE_SECRET_FIELD: &str = "user_cache_secret"; -/// The provider cache namespace is an explicit input to every completion. -/// This prevents a V2 request from silently falling back to the legacy, -/// operator-computable SHA256(user UUID) namespace. +/// The provider cache namespace is an explicit input to every completion, +/// derived from the caller's private cache root and verified user. A request +/// without a root is refused, so no completion can fall back to an +/// operator-computable namespace. #[derive(Clone)] -pub(crate) enum CompletionCachePolicy { - LegacyV1, - BoundV2(DerivedCacheNamespaces), -} +pub(crate) struct CompletionCachePolicy(DerivedCacheNamespaces); impl CompletionCachePolicy { pub(crate) fn for_request( - transport: &TransportSession, cache_namespace_root: Option, verified_user_id: Uuid, ) -> Result { - if transport.is_v2() { - let root = cache_namespace_root.ok_or(ApiError::BadRequest)?; - Ok(Self::BoundV2(derive_provider_cache_namespaces( - &root, - verified_user_id, - ))) - } else { - Ok(Self::LegacyV1) - } - } - - pub(crate) const fn requires_provider_done(&self) -> bool { - matches!(self, Self::BoundV2(_)) + let root = cache_namespace_root.ok_or(ApiError::BadRequest)?; + Ok(Self(derive_provider_cache_namespaces( + &root, + verified_user_id, + ))) } } @@ -183,12 +169,10 @@ pub(crate) async fn authorize_completion_caller( state: &AppState, user: &User, auth_method: AuthMethod, - session: &TransportSession, cache_namespace_root: Option, surface: &str, ) -> Result { - let cache_policy = - CompletionCachePolicy::for_request(session, cache_namespace_root, user.uuid)?; + let cache_policy = CompletionCachePolicy::for_request(cache_namespace_root, user.uuid)?; let billing_access = state .chat_billing_access(user.uuid, auth_method == AuthMethod::ApiKey) .await; @@ -595,17 +579,6 @@ fn prepare_tts_request( }) } -fn build_tts_response_payload(body_bytes: &[u8], content_type: &str) -> (Value, bool) { - let is_json_response = serde_json::from_slice::(body_bytes).is_ok(); - ( - json!({ - "content_base64": general_purpose::STANDARD.encode(body_bytes), - "content_type": content_type, - }), - is_json_response, - ) -} - /// Request structure for embeddings endpoints #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)] struct EmbeddingRequest { @@ -1259,26 +1232,16 @@ async fn send_attempt_terminal( let _ = sender.send(CompletionChunk::Terminal(terminal)).await; } -fn stream_end_terminal( - attempt: InferenceAttempt, - saw_finish_signal: bool, - has_incomplete_frame: bool, - require_provider_done: bool, -) -> AttemptTerminal { - if !require_provider_done && saw_finish_signal && !has_incomplete_frame { - AttemptTerminal::Completed { - attempt, - evidence: CompletionEvidence::FinishSignalThenEof, - } - } else { - AttemptTerminal::Failed { - attempt, - failure: AttemptFailure::new( - AttemptFailureKind::UnexpectedEof, - AttemptStage::Stream, - ReplaySafety::NotProvenPreAcceptance, - ), - } +/// A provider stream that ends without `[DONE]` is incomplete, whatever finish +/// evidence preceded the end of the stream. +fn stream_end_terminal(attempt: InferenceAttempt) -> AttemptTerminal { + AttemptTerminal::Failed { + attempt, + failure: AttemptFailure::new( + AttemptFailureKind::UnexpectedEof, + AttemptStage::Stream, + ReplaySafety::NotProvenPreAcceptance, + ), } } @@ -1429,7 +1392,6 @@ async fn process_completion_stream( tx_consumer: &mpsc::Sender, chunk_timeout: Duration, response_execution: Option<&ResponseExecution>, - require_provider_done: bool, ) -> StreamProcessResult { process_completion_stream_with_frame_limit( response, @@ -1438,7 +1400,6 @@ async fn process_completion_stream( tx_consumer, chunk_timeout, response_execution, - require_provider_done, None, ) .await @@ -1455,7 +1416,6 @@ async fn process_completion_stream_with_frame_limit( tx_consumer: &mpsc::Sender, chunk_timeout: Duration, response_execution: Option<&ResponseExecution>, - require_provider_done: bool, frame_limit: Option, ) -> StreamProcessResult { let mut body_stream = response.bytes_stream(); @@ -1604,13 +1564,7 @@ async fn process_completion_stream_with_frame_limit( ); } Ok(None) => { - let has_incomplete_frame = buffer.iter().any(|byte| !byte.is_ascii_whitespace()); - let terminal = stream_end_terminal( - attempt, - usage_accumulator.saw_terminal_signal, - has_incomplete_frame, - require_provider_done, - ); + let terminal = stream_end_terminal(attempt); return finish_stream_processing( &mut usage_accumulator, StreamUsageFinalization::EndOfStream, @@ -2081,7 +2035,6 @@ async fn proxy_openai( &state, &user, auth_method, - &session_id, cache_namespace_root.map(|axum::Extension(root)| root), "chat", ) @@ -2246,7 +2199,6 @@ async fn proxy_openai( debug!("Handling streaming response"); let mut rx = completion.stream; - let require_explicit_terminal = session_id.is_v2(); let stream = async_stream::stream! { let mut saw_terminal = false; while let Some(chunk) = rx.recv().await { @@ -2302,7 +2254,7 @@ async fn proxy_openai( } } - if require_explicit_terminal && !saw_terminal { + if !saw_terminal { error!("Completion stream closed without a terminal event"); match encrypt_sse_event( &state, @@ -2756,7 +2708,6 @@ pub(crate) struct StartedCompletion { billing_context: BillingContext, non_streaming_body_limit: Option, stream_frame_limit: Option, - require_provider_done: bool, response_execution: Option, response_execution_guard: Option, } @@ -2765,7 +2716,6 @@ pub(crate) struct StartedCompletion { /// request and returns immediately after a successful provider response start. pub(crate) async fn start_chat_completion_response( state: &Arc, - user: &User, body: Value, headers: &HeaderMap, execution: CompletionExecutionContext<'_>, @@ -2773,7 +2723,6 @@ pub(crate) async fn start_chat_completion_response( ) -> Result { get_chat_completion_response_with_options( state, - user, body, headers, execution, @@ -2787,7 +2736,6 @@ pub(crate) async fn start_chat_completion_response( /// remains held across the persistence boundary and subsequent processing. pub(crate) async fn start_chat_completion_response_for_execution( state: &Arc, - user: &User, body: Value, headers: &HeaderMap, execution: CompletionExecutionContext<'_>, @@ -2797,7 +2745,6 @@ pub(crate) async fn start_chat_completion_response_for_execution( let execution = execution.with_response_execution(response_execution)?; get_chat_completion_response_with_options( state, - user, body, headers, execution, @@ -2841,7 +2788,6 @@ pub(crate) async fn get_bounded_chat_completion_response( let started = get_chat_completion_response_with_options( state, - user, body, headers, execution, @@ -2915,7 +2861,6 @@ fn log_selected_inference_route(pinned: &PinnedCompletionRequest, attempt: &Infe async fn get_chat_completion_response_with_options( state: &Arc, - user: &User, body: Value, headers: &HeaderMap, execution: CompletionExecutionContext<'_>, @@ -2935,7 +2880,6 @@ async fn get_chat_completion_response_with_options( } let billing_context = &mut billing; let cache_policy = cache; - let require_provider_done = cache_policy.requires_provider_done(); if body.is_null() || body.as_object().is_none_or(|obj| obj.is_empty()) { error!("Request body is empty or invalid"); return Err(ApiError::BadRequest.into()); @@ -3003,7 +2947,6 @@ async fn get_chat_completion_response_with_options( apply_provider_managed_request_fields( &mut modified_body, selected_route.provider.family_name(), - user.uuid, cache_policy, ); billing_context.model_name = selected_route.public_model_id.clone(); @@ -3152,7 +3095,6 @@ async fn get_chat_completion_response_with_options( billing_context: billing, non_streaming_body_limit: options.non_streaming_body_limit, stream_frame_limit: options.stream_frame_limit, - require_provider_done, response_execution, response_execution_guard, }) @@ -3180,7 +3122,6 @@ pub(crate) async fn finish_started_completion( let billing_context = started.billing_context.clone(); let non_streaming_body_limit = started.non_streaming_body_limit; let stream_frame_limit = started.stream_frame_limit; - let require_provider_done = started.require_provider_done; let response_execution = started.response_execution.take(); let response_execution_guard = started.response_execution_guard.take(); @@ -3275,7 +3216,6 @@ pub(crate) async fn finish_started_completion( &tx_consumer, Duration::from_secs(STREAM_CHUNK_TIMEOUT_SECS), response_execution.as_ref(), - require_provider_done, stream_frame_limit, ) .await; @@ -3315,8 +3255,7 @@ pub(crate) async fn get_chat_completion_response( execution: CompletionExecutionContext<'_>, pinned: &PinnedCompletionRequest, ) -> Result { - let started = - start_chat_completion_response(state, user, body, headers, execution, pinned).await?; + let started = start_chat_completion_response(state, body, headers, execution, pinned).await?; finish_started_completion(state, user, started).await } @@ -3403,17 +3342,12 @@ fn ensure_stream_usage(body: &mut serde_json::Map) { } } -fn tinfoil_user_cache_secret(user_uuid: Uuid) -> String { - // Keep the cache namespace stable without exposing the raw user identifier. - hex::encode(Sha256::digest(user_uuid.as_bytes())) -} - pub(crate) fn apply_provider_managed_request_fields( body: &mut serde_json::Map, provider_name: &str, - user_uuid: Uuid, cache_policy: &CompletionCachePolicy, ) { + let CompletionCachePolicy(namespaces) = cache_policy; if body.remove(PROVIDER_MANAGED_CACHE_SALT_FIELD).is_some() { debug!("Stripped provider-managed completion request field: cache_salt"); } @@ -3423,13 +3357,9 @@ pub(crate) fn apply_provider_managed_request_fields( .is_some(); if provider_name == ProviderId::Tinfoil.as_str() { - let user_cache_secret = match cache_policy { - CompletionCachePolicy::LegacyV1 => tinfoil_user_cache_secret(user_uuid), - CompletionCachePolicy::BoundV2(namespace) => namespace.tinfoil_user_cache_secret(), - }; body.insert( PROVIDER_MANAGED_USER_CACHE_SECRET_FIELD.to_string(), - json!(user_cache_secret), + json!(namespaces.tinfoil_user_cache_secret()), ); if replaced_user_cache_secret { debug!("Replaced provider-managed completion request field: user_cache_secret"); @@ -3438,21 +3368,11 @@ pub(crate) fn apply_provider_managed_request_fields( debug!("Stripped provider-managed completion request field: user_cache_secret"); } - let cache_salt = match (provider_name, cache_policy) { + let cache_salt = match provider_name { // Direct vLLM consumes cache_salt. user_cache_secret is translated only // by Tinfoil's shared router, which this endpoint deliberately bypasses. - ("maple", CompletionCachePolicy::LegacyV1) => { - Some(legacy_maple_user_cache_secret(user_uuid)) - } - ("maple", CompletionCachePolicy::BoundV2(namespaces)) => { - Some(namespaces.maple_user_cache_secret()) - } - ("continuum", CompletionCachePolicy::LegacyV1) => { - Some(legacy_continuum_cache_salt(user_uuid)) - } - ("continuum", CompletionCachePolicy::BoundV2(namespaces)) => { - Some(namespaces.continuum_cache_salt()) - } + "maple" => Some(namespaces.maple_user_cache_secret()), + "continuum" => Some(namespaces.continuum_cache_salt()), _ => None, }; if let Some(cache_salt) = cache_salt { @@ -3681,22 +3601,14 @@ fn build_usage_event( } } -/// Helper to encrypt an SSE event +/// Builds one logical SSE event. The Transport V2 gateway encrypts the whole +/// response stream, so the event data is ordinary JSON. async fn encrypt_sse_event( - state: &AppState, - transport_session: &TransportSession, + _state: &AppState, + _transport_session: &TransportSession, json: &Value, ) -> Result { - let json_str = json.to_string(); - let event_data = transport_session - .encode_sse_data(state, &json_str) - .await - .map_err(|e| { - error!("Failed to encode SSE event data: {:?}", e); - ApiError::InternalServerError - })?; - - Ok(sse_event_from_encoded_data(&event_data)) + Ok(sse_event_from_encoded_data(&json.to_string())) } /// OpenAI-style error payload for encrypted in-stream failures. Clients @@ -4075,7 +3987,6 @@ async fn ensure_paid_tts_access(state: &AppState, user: &User) -> Result<(), Api async fn proxy_tts( State(state): State>, - axum::Extension(session_id): axum::Extension, axum::Extension(user): axum::Extension, axum::Extension(_auth_method): axum::Extension, Decrypted(tts_request): Decrypted, @@ -4160,18 +4071,12 @@ async fn proxy_tts( ); } - // Transport V2 encrypts the complete logical HTTP response in the gateway, - // so it can preserve the provider's native audio or JSON bytes. V1 keeps - // its established JSON/base64 response contract unchanged. - if session_id.is_v2() { - return Response::builder() - .header(header::CONTENT_TYPE, response_content_type) - .body(Body::from(body_bytes)) - .map_err(|_| ApiError::InternalServerError); - } - - let (response_payload, _) = build_tts_response_payload(&body_bytes, &response_content_type); - encrypt_response(&state, &session_id, &response_payload).await + // The gateway encrypts the complete logical HTTP response, so the + // provider's native audio or JSON bytes pass through unchanged. + Response::builder() + .header(header::CONTENT_TYPE, response_content_type) + .body(Body::from(body_bytes)) + .map_err(|_| ApiError::InternalServerError) } async fn proxy_embeddings( @@ -4617,13 +4522,6 @@ mod tests { } async fn process_mock_sse(body: &'static str) -> (StreamProcessResult, Vec) { - process_mock_sse_with_policy(body, false).await - } - - async fn process_mock_sse_with_policy( - body: &'static str, - require_provider_done: bool, - ) -> (StreamProcessResult, Vec) { let (trace, server) = call_mock_provider(static_sse_app(body)).await; assert!(trace.prior_failures.is_empty()); let response = match trace.result { @@ -4642,7 +4540,6 @@ mod tests { &tx, Duration::from_secs(1), None, - require_provider_done, ) .await; drop(tx); @@ -4964,7 +4861,6 @@ mod tests { ), non_streaming_body_limit: None, stream_frame_limit: None, - require_provider_done: false, response_execution: None, response_execution_guard: None, }; @@ -5003,7 +4899,7 @@ mod tests { ( "finish then eof", "data: {\"model\":\"upstream-k3\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n", - ExpectedTerminal::Completed(CompletionEvidence::FinishSignalThenEof), + ExpectedTerminal::Failed(AttemptFailureKind::UnexpectedEof), 1, ), ( @@ -6140,7 +6036,6 @@ mod tests { &tx, Duration::from_secs(1), None, - true, Some(frame_limit), ) .await; @@ -6238,7 +6133,6 @@ mod tests { &tx, Duration::from_secs(1), None, - true, Some(1024), ) .await @@ -6267,43 +6161,28 @@ mod tests { } #[tokio::test] - async fn terminal_error_event_round_trips_through_maple_encrypted_sse_contract() { + async fn terminal_error_event_is_plain_json_sse_data() { use axum::body::to_bytes; - use chacha20poly1305::{aead::Aead, ChaCha20Poly1305, Key, KeyInit, Nonce}; use std::convert::Infallible; let payload = completion_error_payload("Inference provider request failed"); let plaintext = payload.to_string(); - let key_bytes = [0x42; 32]; - let nonce_bytes = [0x24; 12]; - let cipher = ChaCha20Poly1305::new(Key::from_slice(&key_bytes)); - let ciphertext = cipher - .encrypt(Nonce::from_slice(&nonce_bytes), plaintext.as_bytes()) - .expect("encrypt mock SSE error payload"); - let encrypted = [nonce_bytes.as_slice(), ciphertext.as_slice()].concat(); - - let event = sse_event_from_encoded_data(&general_purpose::STANDARD.encode(encrypted)); + + let event = sse_event_from_encoded_data(&plaintext); let response = Sse::new(futures::stream::iter([Ok::(event)])).into_response(); let body = to_bytes(response.into_body(), 4096) .await .expect("serialize SSE event"); let body = std::str::from_utf8(&body).expect("SSE body is UTF-8"); - let encoded = body + let data = body .strip_prefix("data: ") .and_then(|value| value.strip_suffix("\n\n")) .expect("one SSE data event"); - assert_ne!(encoded, plaintext); - let decoded = general_purpose::STANDARD - .decode(encoded) - .expect("Maple SDK base64 contract"); - let (nonce, ciphertext) = decoded.split_at(12); - let nonce: [u8; 12] = nonce.try_into().expect("12-byte nonce"); - let decrypted = crate::web::attestation_routes::SessionState::new(key_bytes) - .decrypt(ciphertext, &nonce) - .expect("Maple SDK AEAD contract"); - assert_eq!(decrypted, plaintext.as_bytes()); + // The gateway encrypts the response carrier; the logical event the + // client decrypts is the JSON payload itself. + assert_eq!(data, plaintext); } #[tokio::test] @@ -6349,7 +6228,6 @@ mod tests { &tx, Duration::from_millis(STREAM_CHUNK_TIMEOUT_SECS), None, - false, ) .await; drop(tx); @@ -6409,7 +6287,6 @@ mod tests { &tx, Duration::from_millis(20), None, - false, ) .await; drop(tx); @@ -6467,7 +6344,6 @@ mod tests { &tx, Duration::from_secs(30), None, - false, ), ) .await @@ -6521,7 +6397,6 @@ mod tests { &tx, Duration::from_secs(30), Some(&execution), - false, ), ) .await @@ -6611,7 +6486,6 @@ mod tests { &tx, Duration::from_secs(1), None, - false, ) .await; drop(tx); @@ -6870,12 +6744,10 @@ mod tests { } #[tokio::test] - async fn transport_v2_stream_requires_provider_done_despite_finish_evidence() { - let (without_done, chunks) = process_mock_sse_with_policy( - "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n", - true, - ) - .await; + async fn stream_requires_provider_done_despite_finish_evidence() { + let (without_done, chunks) = + process_mock_sse("data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n") + .await; assert_eq!(chunks.len(), 1); let provider_router = ProviderRouter::default(); let failed_observation = provider_router @@ -6908,13 +6780,10 @@ mod tests { } )); - let (with_done, _) = process_mock_sse_with_policy( - concat!( - "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n", - "data: [DONE]\n\n" - ), - true, - ) + let (with_done, _) = process_mock_sse(concat!( + "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n", + "data: [DONE]\n\n" + )) .await; let completed_observation = provider_router .observe_attempt_terminal(&with_done.terminal, ShadowObservationMode::Update); @@ -6935,21 +6804,14 @@ mod tests { } #[test] - fn stream_eof_requires_prior_finish_evidence() { + fn stream_eof_without_provider_done_is_an_unexpected_eof() { let pinned = pinned_test_completion(); let attempt = pinned .begin_execution() .begin_attempt(pinned.route.identity()); assert!(matches!( - stream_end_terminal(attempt.clone(), true, false, false), - AttemptTerminal::Completed { - evidence: CompletionEvidence::FinishSignalThenEof, - .. - } - )); - assert!(matches!( - stream_end_terminal(attempt, false, false, false), + stream_end_terminal(attempt), AttemptTerminal::Failed { failure: AttemptFailure { kind: AttemptFailureKind::UnexpectedEof, @@ -7347,37 +7209,6 @@ mod tests { )); } - #[test] - fn tts_binary_response_preserves_bytes_and_mime_type() { - let audio_bytes = [b'R', b'I', b'F', b'F', 0, 0xff, b'W', b'A', b'V', b'E']; - let (response, is_json_response) = build_tts_response_payload(&audio_bytes, "audio/flac"); - let decoded = general_purpose::STANDARD - .decode(response["content_base64"].as_str().unwrap()) - .unwrap(); - - assert!(!is_json_response); - assert_eq!(decoded, audio_bytes); - assert_eq!(response["content_type"], "audio/flac"); - } - - #[test] - fn tts_json_response_preserves_exact_bytes_and_problem_mime_type() { - let body = br#"{ "error" : { "message" : "voice generation failed" } }"#; - - let (response, is_json_response) = - build_tts_response_payload(body, "application/problem+json; charset=utf-8"); - let decoded = general_purpose::STANDARD - .decode(response["content_base64"].as_str().unwrap()) - .unwrap(); - - assert!(is_json_response); - assert_eq!(decoded, body); - assert_eq!( - response["content_type"], - "application/problem+json; charset=utf-8" - ); - } - #[test] fn extracts_sse_after_utf8_code_point_is_split_across_chunks() { let json = "{\"choices\":[{\"delta\":{\"content\":\"café\"}}]}"; @@ -7414,28 +7245,24 @@ mod tests { assert!(buffer.is_empty()); } - #[test] - fn tinfoil_user_cache_secret_is_stable_and_unique_per_user() { - let first_user = Uuid::nil(); - let second_user = Uuid::from_u128(1); - - assert_eq!( - tinfoil_user_cache_secret(first_user), - "374708fff7719dd5979ec875d56cd2286f6d3cf7ec317a3b25632aab28ec37bb" - ); - assert_eq!( - tinfoil_user_cache_secret(first_user), - tinfoil_user_cache_secret(first_user) - ); - assert_ne!( - tinfoil_user_cache_secret(first_user), - tinfoil_user_cache_secret(second_user) - ); + fn test_cache_policy(root_byte: u8, user_uuid: Uuid) -> CompletionCachePolicy { + CompletionCachePolicy::for_request( + Some(CacheNamespaceRoot::from_bytes([root_byte; 32])), + user_uuid, + ) + .expect("a cache root yields a cache policy") } #[test] - fn applies_tinfoil_user_cache_secret_and_overwrites_client_value() { + fn tinfoil_cache_namespace_replaces_client_values_and_is_not_operator_computable() { + use sha2::{Digest, Sha256}; + let user_uuid = Uuid::from_u128(42); + let expected = derive_provider_cache_namespaces( + &CacheNamespaceRoot::from_bytes([0x55; 32]), + user_uuid, + ) + .tinfoil_user_cache_secret(); let mut body = serde_json::Map::from_iter([ ("model".to_string(), json!("glm-5-3-flash")), ("cache_salt".to_string(), json!("user-supplied")), @@ -7446,45 +7273,21 @@ mod tests { apply_provider_managed_request_fields( &mut body, ProviderId::Tinfoil.as_str(), - user_uuid, - &CompletionCachePolicy::LegacyV1, + &test_cache_policy(0x55, user_uuid), ); assert_eq!(body.get("model"), Some(&json!("glm-5-3-flash"))); assert_eq!(body.get("messages"), Some(&json!([]))); - assert!(!body.contains_key(PROVIDER_MANAGED_CACHE_SALT_FIELD)); - assert_eq!( - body.get(PROVIDER_MANAGED_USER_CACHE_SECRET_FIELD), - Some(&json!(tinfoil_user_cache_secret(user_uuid))) - ); - } - - #[test] - fn bound_v2_cache_namespace_replaces_legacy_and_client_values() { - let user_uuid = Uuid::from_u128(42); - let root = CacheNamespaceRoot::from_bytes([0x55; 32]); - let namespace = derive_provider_cache_namespaces(&root, user_uuid); - let expected = namespace.tinfoil_user_cache_secret(); - let mut body = serde_json::Map::from_iter([ - ("cache_salt".to_string(), json!("user-supplied")), - ("user_cache_secret".to_string(), json!("client-controlled")), - ]); - - apply_provider_managed_request_fields( - &mut body, - ProviderId::Tinfoil.as_str(), - user_uuid, - &CompletionCachePolicy::BoundV2(namespace), - ); - assert!(!body.contains_key(PROVIDER_MANAGED_CACHE_SALT_FIELD)); assert_eq!( body.get(PROVIDER_MANAGED_USER_CACHE_SECRET_FIELD), Some(&json!(expected)) ); + // A namespace anyone can compute from the user identifier alone would + // let the operator correlate or probe a user's cache. assert_ne!( body.get(PROVIDER_MANAGED_USER_CACHE_SECRET_FIELD), - Some(&json!(tinfoil_user_cache_secret(user_uuid))) + Some(&json!(hex::encode(Sha256::digest(user_uuid.as_bytes())))) ); } @@ -7498,8 +7301,7 @@ mod tests { apply_provider_managed_request_fields( &mut body, "other-provider", - Uuid::from_u128(42), - &CompletionCachePolicy::LegacyV1, + &test_cache_policy(0x55, Uuid::from_u128(42)), ); assert!(!body.contains_key(PROVIDER_MANAGED_CACHE_SALT_FIELD)); @@ -7507,95 +7309,72 @@ mod tests { } #[test] - fn continuum_cache_salt_replaces_caller_fields_for_both_transports() { + fn continuum_cache_salt_replaces_caller_fields() { let user_uuid = Uuid::from_u128(42); - let namespaces = derive_provider_cache_namespaces( + let expected = derive_provider_cache_namespaces( &CacheNamespaceRoot::from_bytes([0x55; 32]), user_uuid, - ); - let v2_salt = namespaces.continuum_cache_salt(); - let v1_salt = legacy_continuum_cache_salt(user_uuid); - assert_ne!(v1_salt, v2_salt); - for (policy, expected) in [ - (CompletionCachePolicy::LegacyV1, v1_salt), - (CompletionCachePolicy::BoundV2(namespaces), v2_salt), + ) + .continuum_cache_salt(); + let policy = test_cache_policy(0x55, user_uuid); + for caller_salt in [ + Value::Null, + json!(""), + json!("caller-controlled"), + json!("x".repeat(64)), + json!(42), + json!({"nested": "value"}), ] { - for caller_salt in [ - Value::Null, - json!(""), - json!("caller-controlled"), - json!("x".repeat(64)), - json!(42), - json!({"nested": "value"}), - ] { - let mut body = serde_json::Map::from_iter([ - ("model".to_string(), json!("provider-model")), - ("cache_salt".to_string(), caller_salt), - ("user_cache_secret".to_string(), json!("caller-controlled")), - ("messages".to_string(), json!([])), - ]); - apply_provider_managed_request_fields( - &mut body, - ProviderId::Continuum.as_str(), - user_uuid, - &policy, - ); - assert_eq!(body.get("cache_salt"), Some(&json!(expected))); - assert!(!body.contains_key("user_cache_secret")); - assert_eq!(body.get("model"), Some(&json!("provider-model"))); - assert_eq!(body.get("messages"), Some(&json!([]))); - } + let mut body = serde_json::Map::from_iter([ + ("model".to_string(), json!("provider-model")), + ("cache_salt".to_string(), caller_salt), + ("user_cache_secret".to_string(), json!("caller-controlled")), + ("messages".to_string(), json!([])), + ]); + apply_provider_managed_request_fields( + &mut body, + ProviderId::Continuum.as_str(), + &policy, + ); + assert_eq!(body.get("cache_salt"), Some(&json!(expected))); + assert!(!body.contains_key("user_cache_secret")); + assert_eq!(body.get("model"), Some(&json!("provider-model"))); + assert_eq!(body.get("messages"), Some(&json!([]))); + } - // Every turn, including internal exact-route completions, passes - // through this same boundary with the original cache policy. - let mut body = serde_json::Map::new(); - for turn_policy in [&policy, &policy.clone()] { - apply_provider_managed_request_fields( - &mut body, - ProviderId::Continuum.as_str(), - user_uuid, - turn_policy, - ); - assert_eq!(body.get("cache_salt"), Some(&json!(expected))); - } + // Every turn, including internal exact-route completions, passes + // through this same boundary with the original cache policy. + let mut body = serde_json::Map::new(); + for turn_policy in [&policy, &policy.clone()] { + apply_provider_managed_request_fields( + &mut body, + ProviderId::Continuum.as_str(), + turn_policy, + ); + assert_eq!(body.get("cache_salt"), Some(&json!(expected))); } } #[test] - fn v2_completion_cache_policy_requires_a_root_and_binds_verified_identity() { - use crate::transport_v2::crypto::SessionId; - - let transport = TransportSession::v2(SessionId::from_bytes([0x11; 16])); + fn completion_cache_policy_requires_a_root_and_binds_verified_identity() { let user = Uuid::from_u128(1); assert!(matches!( - CompletionCachePolicy::for_request(&transport, None, user), + CompletionCachePolicy::for_request(None, user), Err(ApiError::BadRequest) )); - let root = CacheNamespaceRoot::from_bytes([0x42; 32]); - let policy = - CompletionCachePolicy::for_request(&transport, Some(root.clone()), user).unwrap(); - assert!(policy.requires_provider_done()); let mut first = serde_json::Map::new(); apply_provider_managed_request_fields( &mut first, ProviderId::Continuum.as_str(), - user, - &policy, + &test_cache_policy(0x42, user), ); - for (other_user, other_root) in [ - (Uuid::from_u128(2), root), - (user, CacheNamespaceRoot::from_bytes([0x24; 32])), - ] { - let other_policy = - CompletionCachePolicy::for_request(&transport, Some(other_root), other_user) - .unwrap(); + for (other_user, other_root) in [(Uuid::from_u128(2), 0x42), (user, 0x24)] { let mut other = serde_json::Map::new(); apply_provider_managed_request_fields( &mut other, ProviderId::Continuum.as_str(), - other_user, - &other_policy, + &test_cache_policy(other_root, other_user), ); assert_ne!(first.get("cache_salt"), other.get("cache_salt")); } diff --git a/services/opensecret/src/web/openai/maple_tests.rs b/services/opensecret/src/web/openai/maple_tests.rs index 953a8a33f..064887997 100644 --- a/services/opensecret/src/web/openai/maple_tests.rs +++ b/services/opensecret/src/web/openai/maple_tests.rs @@ -20,7 +20,10 @@ fn uncensored_completion_access_uses_the_existing_pro_plan_gate() { #[test] fn nested_and_pinned_completion_contexts_preserve_plan_without_provider_flag() { - let cache = CompletionCachePolicy::LegacyV1; + let cache = CompletionCachePolicy(derive_provider_cache_namespaces( + &CacheNamespaceRoot::from_bytes([0x42; 32]), + Uuid::from_u128(17), + )); let caller = InferenceRoutingContext::new(ModelPlan::Paid); let child = caller.with_model_plan(ModelPlan::Free); assert_eq!(child.model_plan(), ModelPlan::Free); @@ -69,7 +72,7 @@ fn nested_and_pinned_completion_contexts_preserve_plan_without_provider_flag() { fn maple_instance_routes_keep_shared_cache_namespace_and_billing_identity() { let user = Uuid::from_u128(17); let model = crate::model_config::DEEPSEEK_V4_1_FLASH_MODEL_ID; - let cache = CompletionCachePolicy::BoundV2(derive_provider_cache_namespaces( + let cache = CompletionCachePolicy(derive_provider_cache_namespaces( &CacheNamespaceRoot::from_bytes([0x42; 32]), user, )); @@ -103,12 +106,7 @@ fn maple_instance_routes_keep_shared_cache_namespace_and_billing_identity() { let mut body = serde_json::Map::new(); body.insert("cache_salt".to_owned(), json!("caller-controlled")); - apply_provider_managed_request_fields( - &mut body, - route.provider.family_name(), - user, - &cache, - ); + apply_provider_managed_request_fields(&mut body, route.provider.family_name(), &cache); let salt = body.get("cache_salt").cloned().unwrap(); assert_ne!(salt, json!("caller-controlled")); if let Some(prior) = prior_salt.replace(salt.clone()) { @@ -266,91 +264,60 @@ fn direct_maple_cache_salt_is_private_and_provider_fields_are_rebuilt() { let other_user = Uuid::from_u128(2); let root = CacheNamespaceRoot::from_bytes([0x42; 32]); let namespaces = derive_provider_cache_namespaces(&root, user); - let policies = [ - CompletionCachePolicy::LegacyV1, - CompletionCachePolicy::BoundV2(namespaces), - ]; - for policy in policies { - let expected = match &policy { - CompletionCachePolicy::LegacyV1 => legacy_maple_user_cache_secret(user), - CompletionCachePolicy::BoundV2(namespace) => namespace.maple_user_cache_secret(), - }; - for untrusted in [ - json!("caller-controlled"), - json!(null), - json!({"other_user": "injected"}), - json!(["injected"]), - json!(123), - json!(false), - ] { - let mut body = json!({ - "model": "deepseek-v4-1-flash", - "messages": [{"role": "user", "content": "synthetic cache boundary test"}], - "user_cache_secret": untrusted, - "cache_salt": untrusted, - "temperature": 0.5 - }) - .as_object() - .unwrap() - .clone(); - apply_provider_managed_request_fields( - &mut body, - ProviderId::Maple(MapleInstanceId::I01).family_name(), - user, - &policy, - ); - // Dedicated endpoints expose native vLLM, which uses cache_salt. - // user_cache_secret belongs to Tinfoil's shared-router contract. - assert_eq!(body.get("cache_salt"), Some(&json!(expected))); - assert!(!body.contains_key("user_cache_secret")); - assert_eq!(body.get("model"), Some(&json!("deepseek-v4-1-flash"))); - assert_eq!(body.get("temperature"), Some(&json!(0.5))); + let expected = namespaces.maple_user_cache_secret(); + let shared_expected = namespaces.tinfoil_user_cache_secret(); + let continuum_expected = namespaces.continuum_cache_salt(); + let policy = CompletionCachePolicy(namespaces); + let other_policy = CompletionCachePolicy(derive_provider_cache_namespaces(&root, other_user)); + for untrusted in [ + json!("caller-controlled"), + json!(null), + json!({"other_user": "injected"}), + json!(["injected"]), + json!(123), + json!(false), + ] { + let mut body = json!({ + "model": "deepseek-v4-1-flash", + "messages": [{"role": "user", "content": "synthetic cache boundary test"}], + "user_cache_secret": untrusted, + "cache_salt": untrusted, + "temperature": 0.5 + }) + .as_object() + .unwrap() + .clone(); + apply_provider_managed_request_fields( + &mut body, + ProviderId::Maple(MapleInstanceId::I01).family_name(), + &policy, + ); + // Dedicated endpoints expose native vLLM, which uses cache_salt. + // user_cache_secret belongs to Tinfoil's shared-router contract. + assert_eq!(body.get("cache_salt"), Some(&json!(expected))); + assert!(!body.contains_key("user_cache_secret")); + assert_eq!(body.get("model"), Some(&json!("deepseek-v4-1-flash"))); + assert_eq!(body.get("temperature"), Some(&json!(0.5))); - let mut other_body = body.clone(); - let other_policy = match &policy { - CompletionCachePolicy::LegacyV1 => CompletionCachePolicy::LegacyV1, - CompletionCachePolicy::BoundV2(_) => CompletionCachePolicy::BoundV2( - derive_provider_cache_namespaces(&root, other_user), - ), - }; - apply_provider_managed_request_fields( - &mut other_body, - ProviderId::Maple(MapleInstanceId::I01).family_name(), - other_user, - &other_policy, - ); - assert_ne!(other_body.get("cache_salt"), body.get("cache_salt")); + let mut other_body = body.clone(); + apply_provider_managed_request_fields( + &mut other_body, + ProviderId::Maple(MapleInstanceId::I01).family_name(), + &other_policy, + ); + assert_ne!(other_body.get("cache_salt"), body.get("cache_salt")); - // Provider field normalization is independent of model identity. - // Rebuilding fields must never retain another provider's salt; - // this does not authorize fallback between different checkpoints. - apply_provider_managed_request_fields( - &mut body, - ProviderId::Tinfoil.as_str(), - user, - &policy, - ); - let shared_expected = match &policy { - CompletionCachePolicy::LegacyV1 => tinfoil_user_cache_secret(user), - CompletionCachePolicy::BoundV2(namespace) => namespace.tinfoil_user_cache_secret(), - }; - assert_eq!(body.get("user_cache_secret"), Some(&json!(shared_expected))); - assert_ne!(body.get("user_cache_secret"), Some(&json!(expected))); - assert!(!body.contains_key("cache_salt")); + // Provider field normalization is independent of model identity. + // Rebuilding fields must never retain another provider's salt; + // this does not authorize fallback between different checkpoints. + apply_provider_managed_request_fields(&mut body, ProviderId::Tinfoil.as_str(), &policy); + assert_eq!(body.get("user_cache_secret"), Some(&json!(shared_expected))); + assert_ne!(body.get("user_cache_secret"), Some(&json!(expected))); + assert!(!body.contains_key("cache_salt")); - apply_provider_managed_request_fields( - &mut body, - ProviderId::Continuum.as_str(), - user, - &policy, - ); - let continuum_expected = match &policy { - CompletionCachePolicy::LegacyV1 => legacy_continuum_cache_salt(user), - CompletionCachePolicy::BoundV2(namespace) => namespace.continuum_cache_salt(), - }; - assert!(!body.contains_key("user_cache_secret")); - assert_eq!(body.get("cache_salt"), Some(&json!(continuum_expected))); - assert_ne!(body.get("cache_salt"), Some(&json!(expected))); - } + apply_provider_managed_request_fields(&mut body, ProviderId::Continuum.as_str(), &policy); + assert!(!body.contains_key("user_cache_secret")); + assert_eq!(body.get("cache_salt"), Some(&json!(continuum_expected))); + assert_ne!(body.get("cache_salt"), Some(&json!(expected))); } } diff --git a/services/opensecret/src/web/openai_auth.rs b/services/opensecret/src/web/openai_auth.rs index 9985e7fa5..8f01cdfde 100644 --- a/services/opensecret/src/web/openai_auth.rs +++ b/services/opensecret/src/web/openai_auth.rs @@ -1,13 +1,11 @@ -use crate::jwt::{ - validate_access_token_for_auth, AuthContext, TRANSPORT_V2_USER_ACCESS, USER_ACCESS, -}; +use crate::jwt::{validate_access_token_for_auth, AuthContext, TRANSPORT_V2_USER_ACCESS}; use crate::transport_v2::envelope::{Credential, CredentialKind}; use crate::web::encryption_middleware::TransportSession; use crate::ApiError; use axum::{ body::Body, extract::State, - http::{header, Request}, + http::Request, middleware::Next, response::{IntoResponse, Response}, }; @@ -32,34 +30,20 @@ pub async fn validate_openai_auth( mut req: Request, next: Next, ) -> Response { - let is_transport_v2 = req - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - let presented = if is_transport_v2 { - match req.extensions().get::() { - Some(credential) if credential.kind() == CredentialKind::ApiKey => { - PresentedCredential::ApiKey(credential.value()) - } - Some(credential) if credential.kind() == CredentialKind::Bearer => { - PresentedCredential::Bearer(credential.value()) - } - _ => return ApiError::InvalidJwt.into_response(), + // Credentials arrive only inside the Transport V2 envelope. A request + // that did not come through the gateway has no transport session, and + // outer HTTP headers are never read. + if req.extensions().get::().is_none() { + return ApiError::InvalidJwt.into_response(); + } + let presented = match req.extensions().get::() { + Some(credential) if credential.kind() == CredentialKind::ApiKey => { + PresentedCredential::ApiKey(credential.value()) } - } else { - let Some(value) = req - .headers() - .get(header::AUTHORIZATION) - .and_then(|value| value.to_str().ok()) - .and_then(|value| value.strip_prefix("Bearer ")) - else { - return ApiError::InvalidJwt.into_response(); - }; - if value.contains('.') { - PresentedCredential::Bearer(value) - } else { - PresentedCredential::ApiKey(value) + Some(credential) if credential.kind() == CredentialKind::Bearer => { + PresentedCredential::Bearer(credential.value()) } + _ => return ApiError::InvalidJwt.into_response(), }; let token = match presented { @@ -84,26 +68,16 @@ pub async fn validate_openai_auth( } } } - Err(_) if is_transport_v2 => return ApiError::Unauthorized.into_response(), - // Preserve V1's legacy behavior: a non-UUID bearer without dots - // falls through to JWT validation and returns InvalidJwt. - Err(_) => api_key, + Err(_) => return ApiError::Unauthorized.into_response(), }, PresentedCredential::Bearer(token) => token, }; - let (claims, access_token_expired) = match validate_access_token_for_auth( - token, - &data, - if is_transport_v2 { - TRANSPORT_V2_USER_ACCESS - } else { - USER_ACCESS - }, - ) { - Ok(validation) => validation, - Err(_) => return ApiError::InvalidJwt.into_response(), - }; + let (claims, access_token_expired) = + match validate_access_token_for_auth(token, &data, TRANSPORT_V2_USER_ACCESS) { + Ok(validation) => validation, + Err(_) => return ApiError::InvalidJwt.into_response(), + }; let auth_context = match AuthContext::from_claims(&claims) { Ok(auth_context) => auth_context, @@ -157,16 +131,7 @@ pub async fn validate_optional_openai_auth( req: Request, next: Next, ) -> Response { - let is_transport_v2 = req - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - let has_credential = if is_transport_v2 { - req.extensions().get::().is_some() - } else { - req.headers().contains_key(header::AUTHORIZATION) - }; - if !has_credential { + if req.extensions().get::().is_none() { return next.run(req).await; } diff --git a/services/opensecret/src/web/platform/login_routes.rs b/services/opensecret/src/web/platform/login_routes.rs index 72291b228..b6167d38e 100644 --- a/services/opensecret/src/web/platform/login_routes.rs +++ b/services/opensecret/src/web/platform/login_routes.rs @@ -1,6 +1,6 @@ use crate::{ email::send_platform_verification_email, - jwt::{NewToken, TokenType, PLATFORM_REFRESH}, + jwt::{NewToken, TokenType}, models::{ org_memberships::OrgRole, platform_email_verification::NewPlatformEmailVerification, platform_users::NewPlatformUser, @@ -13,7 +13,7 @@ use axum::{ body::{Body, HttpBody}, extract::{Path, State}, http::Request, - middleware::{from_fn_with_state, Next}, + middleware::{from_fn, from_fn_with_state, Next}, response::Response, routing::{get, post}, Extension, Router, @@ -160,10 +160,7 @@ pub fn router(app_state: Arc) -> Router<()> { ) .route( "/platform/refresh", - post(refresh_platform_token).layer(from_fn_with_state( - app_state.clone(), - prepare_platform_refresh_request, - )), + post(refresh_platform_token).layer(from_fn(prepare_platform_refresh_request)), ) .route( "/platform/logout", @@ -194,33 +191,27 @@ pub fn router(app_state: Arc) -> Router<()> { .with_state(app_state) } +/// Takes the refresh token from the request envelope's resumption credential. +/// A refresh request has no logical body. async fn prepare_platform_refresh_request( - State(state): State>, mut request: Request, next: Next, ) -> Result { - let is_transport_v2 = request - .extensions() - .get::() - .is_some_and(TransportSession::is_v2); - if is_transport_v2 { - if request.body().size_hint().exact() != Some(0) { - return Err(ApiError::BadRequest); - } - let refresh_token = request - .extensions() - .get::() - .filter(|credential| credential.kind() == CredentialKind::Resumption) - .map(|credential| credential.value().to_string()) - .ok_or(ApiError::InvalidJwt)?; - request - .extensions_mut() - .insert(PlatformRefreshRequest { refresh_token }); - return Ok(next.run(request).await); + if request.extensions().get::().is_none() + || request.body().size_hint().exact() != Some(0) + { + return Err(ApiError::BadRequest); } - - let headers = request.headers().clone(); - decrypt_request::(State(state), headers, request, next).await + let refresh_token = request + .extensions() + .get::() + .filter(|credential| credential.kind() == CredentialKind::Resumption) + .map(|credential| credential.value().to_string()) + .ok_or(ApiError::InvalidJwt)?; + request + .extensions_mut() + .insert(PlatformRefreshRequest { refresh_token }); + Ok(next.run(request).await) } pub async fn login_platform_user( @@ -234,8 +225,7 @@ pub async fn login_platform_user( return Err(ApiError::BadRequest); } - let auth_response = - login_internal_platform(data.clone(), login_request, session_id.is_v2()).await?; + let auth_response = login_internal_platform(data.clone(), login_request).await?; let result = encrypt_response(&data, &session_id, &auth_response).await; result } @@ -243,7 +233,6 @@ pub async fn login_platform_user( async fn login_internal_platform( data: Arc, login_request: PlatformLoginRequest, - is_transport_v2: bool, ) -> Result { // Authenticate the platform user match data @@ -254,12 +243,12 @@ async fn login_internal_platform( // Generate tokens let access_token = NewToken::new_for_platform_user( &platform_user, - TokenType::access_for_transport(is_transport_v2), + TokenType::TransportV2Access, &data, )?; let refresh_token = NewToken::new_for_platform_user( &platform_user, - TokenType::refresh_for_transport(is_transport_v2), + TokenType::TransportV2Refresh, &data, )?; @@ -373,16 +362,10 @@ pub async fn register_platform_user( }); // Generate tokens - let access_token = NewToken::new_for_platform_user( - &platform_user, - TokenType::access_for_transport(session_id.is_v2()), - &data, - )?; - let refresh_token = NewToken::new_for_platform_user( - &platform_user, - TokenType::refresh_for_transport(session_id.is_v2()), - &data, - )?; + let access_token = + NewToken::new_for_platform_user(&platform_user, TokenType::TransportV2Access, &data)?; + let refresh_token = + NewToken::new_for_platform_user(&platform_user, TokenType::TransportV2Refresh, &data)?; let response = PlatformAuthResponse { id: platform_user.uuid, @@ -407,29 +390,21 @@ pub async fn refresh_platform_token( return Err(ApiError::BadRequest); } - let refresh_audience = if session_id.is_v2() { - crate::jwt::TRANSPORT_V2_PLATFORM_REFRESH - } else { - PLATFORM_REFRESH - }; - let claims = - crate::jwt::validate_token(&refresh_request.refresh_token, &data, refresh_audience)?; + let claims = crate::jwt::validate_token( + &refresh_request.refresh_token, + &data, + crate::jwt::TRANSPORT_V2_PLATFORM_REFRESH, + )?; let platform_user_id = Uuid::parse_str(&claims.sub).map_err(|_| ApiError::InvalidJwt)?; // Verify platform user still exists let platform_user = data.db.get_platform_user_by_uuid(platform_user_id)?; // Generate new tokens - let new_access_token = NewToken::new_for_platform_user( - &platform_user, - TokenType::access_for_transport(session_id.is_v2()), - &data, - )?; - let new_refresh_token = NewToken::new_for_platform_user( - &platform_user, - TokenType::refresh_for_transport(session_id.is_v2()), - &data, - )?; + let new_access_token = + NewToken::new_for_platform_user(&platform_user, TokenType::TransportV2Access, &data)?; + let new_refresh_token = + NewToken::new_for_platform_user(&platform_user, TokenType::TransportV2Refresh, &data)?; let response = PlatformRefreshResponse { access_token: new_access_token.token, diff --git a/services/opensecret/src/web/protected_routes.rs b/services/opensecret/src/web/protected_routes.rs index f3b1c29ae..687ae3b52 100644 --- a/services/opensecret/src/web/protected_routes.rs +++ b/services/opensecret/src/web/protected_routes.rs @@ -8,8 +8,7 @@ use crate::private_key::{ use crate::recovery_code::RecoveryCode; use crate::seed_wrapping::new_recovery_seed_wrapping; use crate::web::encryption_middleware::{ - decrypt_request, encrypt_response, require_transport_v2, require_v2_transport_session, - Decrypted, TransportSession, + decrypt_request, encrypt_response, Decrypted, TransportSession, }; use crate::web::password_policy::validate_password; use crate::Error; @@ -21,7 +20,6 @@ use crate::{ // BIP-85 constants const BIP85_PURPOSE: u32 = 83696968; // BIP-85 purpose value const BIP85_APPLICATION_BIP39: u32 = 39; // Application number for BIP-39 mnemonics -use axum::middleware::from_fn; use axum::middleware::from_fn_with_state; use axum::Extension; use axum::{ @@ -803,13 +801,13 @@ pub async fn change_password( Ok(new_auth_context) => { let access_token = NewToken::new_with_auth_context( &user, - TokenType::access_for_transport(session_id.is_v2()), + TokenType::TransportV2Access, &data, &new_auth_context, )?; let refresh_token = NewToken::new_with_auth_context( &user, - TokenType::refresh_for_transport(session_id.is_v2()), + TokenType::TransportV2Refresh, &data, &new_auth_context, )?; @@ -1385,8 +1383,7 @@ pub async fn delete_api_key( /// /// Carries its own `validate_jwt` layer so it can be merged outside the /// shared `protected_routes` JWT scope (which would otherwise validate the -/// same JWT twice), plus the v2-transport gate that rejects legacy v1 -/// sessions before any recovery logic runs. +/// same JWT twice). pub fn recovery_router(app_state: Arc) -> Router<()> { Router::new() .route( @@ -1416,7 +1413,6 @@ pub fn recovery_router(app_state: Arc) -> Router<()> { )), ) .route_layer(from_fn_with_state(app_state.clone(), validate_jwt)) - .route_layer(from_fn(require_transport_v2)) .with_state(app_state) } @@ -1481,7 +1477,6 @@ pub async fn recovery_status( Extension(user): Extension, Extension(transport_session): Extension, ) -> Result { - require_v2_transport_session(&transport_session)?; let status = data.db.get_recovery_wrap(user.uuid).map_err(|e| { error!("Failed to load recovery status: {:?}", e); ApiError::InternalServerError @@ -1502,7 +1497,6 @@ pub async fn enroll_recovery( Extension(transport_session): Extension, Decrypted(request): Decrypted, ) -> Result { - require_v2_transport_session(&transport_session)?; require_email_password_user(&user)?; require_current_password(&data, &user, request.current_password).await?; @@ -1562,7 +1556,6 @@ pub async fn rotate_recovery( Extension(transport_session): Extension, Decrypted(request): Decrypted, ) -> Result { - require_v2_transport_session(&transport_session)?; require_email_password_user(&user)?; require_current_password(&data, &user, request.current_password).await?; @@ -1615,7 +1608,6 @@ pub async fn disable_recovery( Extension(transport_session): Extension, Decrypted(request): Decrypted, ) -> Result { - require_v2_transport_session(&transport_session)?; require_email_password_user(&user)?; require_current_password(&data, &user, request.current_password).await?; @@ -2121,12 +2113,7 @@ mod api_key_validation_tests { #[cfg(test)] mod recovery_guard_tests { use super::*; - use crate::transport_v2::crypto::SessionId; - use axum::body::Body; - use axum::http::{Request, Request as HttpRequest, StatusCode}; - use axum::routing::get; use serde_json::json; - use tower::ServiceExt; fn user_fixture(email: Option<&str>, password_enc: Option>) -> User { serde_json::from_value(json!({ @@ -2142,21 +2129,6 @@ mod recovery_guard_tests { .expect("user fixture should deserialize") } - #[test] - fn v1_session_is_rejected_at_handler_boundary() { - let session = TransportSession::v1(Uuid::new_v4()); - assert!( - require_v2_transport_session(&session).is_err(), - "a v1 transport session must not reach recovery handler logic" - ); - } - - #[test] - fn v2_session_passes_handler_boundary_guard() { - let session = TransportSession::v2(SessionId::from_bytes([0x22; 16])); - assert!(require_v2_transport_session(&session).is_ok()); - } - #[test] fn guests_cannot_manage_recovery() { let guest = user_fixture(None, None); @@ -2174,69 +2146,4 @@ mod recovery_guard_tests { let password_user = user_fixture(Some("user@example.com"), Some(vec![1, 2, 3])); assert!(require_email_password_user(&password_user).is_ok()); } - - #[tokio::test] - async fn recovery_router_rejects_v1_transport_session() { - let router = recovery_test_router(); - let request = HttpRequest::builder() - .uri("/protected/recovery-code") - .body(Body::empty()) - .unwrap(); - // In production the v1 gateway inserts this extension; the test - // reproduces an authenticated-but-v1 transport reaching the router. - let extension = TransportSession::v1(Uuid::new_v4()); - let request = attach_transport(request, extension); - let response = router.oneshot(request).await.unwrap(); - assert_eq!(response.status(), StatusCode::BAD_REQUEST); - } - - #[tokio::test] - async fn recovery_router_rejects_missing_transport_session() { - let router = recovery_test_router(); - let request = HttpRequest::builder() - .uri("/protected/recovery-code") - .body(Body::empty()) - .unwrap(); - let response = router.oneshot(request).await.unwrap(); - assert_eq!(response.status(), StatusCode::BAD_REQUEST); - } - - #[tokio::test] - async fn recovery_router_accepts_v2_transport_session() { - let router = recovery_test_router(); - let request = HttpRequest::builder() - .uri("/protected/recovery-code") - .body(Body::empty()) - .unwrap(); - let extension = TransportSession::v2(SessionId::from_bytes([0x22; 16])); - let request = attach_transport(request, extension); - let response = router.oneshot(request).await.unwrap(); - assert_eq!(response.status(), StatusCode::OK); - } - - fn attach_transport(request: Request, session: TransportSession) -> Request { - let (mut parts, body) = request.into_parts(); - parts.extensions.insert(session); - Request::from_parts(parts, body) - } - - fn recovery_test_router() -> Router<()> { - Router::new() - .route( - "/protected/recovery-code", - get( - |Extension(session): Extension| async move { - // This handler would perform recovery status work; the - // test handler only reports whether the transport gate - // let it run. - if session.is_v2() { - StatusCode::OK - } else { - StatusCode::CONFLICT - } - }, - ), - ) - .layer(from_fn(require_transport_v2)) - } } diff --git a/services/opensecret/src/web/remote/mod.rs b/services/opensecret/src/web/remote/mod.rs index 98ecafef3..6febbe912 100644 --- a/services/opensecret/src/web/remote/mod.rs +++ b/services/opensecret/src/web/remote/mod.rs @@ -286,9 +286,6 @@ async fn register( Extension(user): Extension, Decrypted(request): Decrypted, ) -> Result { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } let worker = state.clone(); let value = tokio::task::spawn_blocking(move || register_inner(&worker, &user, request)) .await @@ -301,9 +298,6 @@ async fn list( Extension(session): Extension, Extension(user): Extension, ) -> Result { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } let worker = state.clone(); let devices = tokio::task::spawn_blocking(move || { let now = Utc::now().timestamp(); @@ -404,9 +398,6 @@ async fn admit( Extension(user): Extension, Decrypted(request): Decrypted, ) -> Result { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } let worker = state.clone(); let value = tokio::task::spawn_blocking(move || admit_inner(&worker, &user, request)) .await @@ -420,9 +411,6 @@ async fn check( Extension(user): Extension, Decrypted(request): Decrypted, ) -> Result { - if !session.is_v2() { - return Err(ApiError::BadRequest); - } let worker = state.clone(); let valid = tokio::task::spawn_blocking(move || { let id = admission_id(&request.handle)?; diff --git a/services/opensecret/src/web/responses/handlers.rs b/services/opensecret/src/web/responses/handlers.rs index b98219328..071fa4e55 100644 --- a/services/opensecret/src/web/responses/handlers.rs +++ b/services/opensecret/src/web/responses/handlers.rs @@ -6777,7 +6777,6 @@ async fn ensure_message_started( #[allow(clippy::too_many_arguments)] async fn start_responses_assistant_turn( state: &Arc, - user: &User, body: &ResponsesCreateRequest, pinned_completion: &PinnedCompletionRequest, headers: &HeaderMap, @@ -6818,7 +6817,6 @@ async fn start_responses_assistant_turn( start_chat_completion_response_for_execution( state, - user, chat_request.take(), headers, CompletionExecutionContext::for_pinned(billing_context, pinned_completion, cache_policy), @@ -7180,7 +7178,6 @@ async fn setup_completion_processor( loop { match start_responses_assistant_turn( state, - user, body, pinned_completion, headers, @@ -7802,7 +7799,6 @@ async fn create_streaming_preparation_response( let turn_body = model_turn_request_without_user_payload(&work.body); let first_started = match start_responses_assistant_turn( &state, - &user, &turn_body, &work.pinned_completion, &headers, @@ -7848,7 +7844,6 @@ async fn create_streaming_preparation_response( .await?; start_responses_assistant_turn( &state, - &user, &turn_body, &work.pinned_completion, &headers, @@ -7994,7 +7989,6 @@ async fn create_response_stream_inner( ) -> Result { let client_app = ClientApp::from_headers(&headers); let cache_policy = CompletionCachePolicy::for_request( - &session_id, cache_namespace_root.map(|Extension(root)| root), user.uuid, )?; @@ -8458,7 +8452,6 @@ async fn create_response_stream_inner( execution_policy.deadline, start_responses_assistant_turn( &state, - &user, &model_turn_body, &pinned_completion, &headers, @@ -8522,7 +8515,6 @@ async fn create_response_stream_inner( execution_policy.deadline, start_responses_assistant_turn( &state, - &user, &model_turn_body, &pinned_completion, &headers, @@ -8729,7 +8721,6 @@ fn response_client_sse( preparation_start: Option>, ) -> Response { let response_uuid = response_for_stream.uuid; - let require_explicit_terminal = session_id.is_v2(); let mut client_execution_guard = Some(client_execution_guard); // Storage and execution are already running; the body only translates the // ordered client channel into encrypted SSE events. @@ -9149,7 +9140,7 @@ fn response_client_sse( } } - if require_explicit_terminal && !saw_terminal { + if !saw_terminal { error!("Responses client stream closed without a terminal event"); // No storage-authoritative terminal arrived. Fail the body so the // V2 gateway emits an authenticated transport error, without claiming @@ -9229,22 +9220,15 @@ pub(crate) fn responses_sse_body_failure_for_test() -> Response { ])) } -/// Helper to create encrypted SSE event +/// Builds one logical SSE event. The Transport V2 gateway encrypts the whole +/// response stream, so the event data is ordinary JSON. pub async fn encrypt_event( - state: &AppState, - transport_session: &TransportSession, + _state: &AppState, + _transport_session: &TransportSession, event_type: &str, payload: &Value, ) -> Result { - let payload_str = payload.to_string(); - let event_data = transport_session - .encode_sse_data(state, &payload_str) - .await - .map_err(|e| { - error!("Failed to encode event data: {:?}", e); - ApiError::InternalServerError - })?; - Ok(Event::default().event(event_type).data(event_data)) + Ok(Event::default().event(event_type).data(payload.to_string())) } /// GET /v1/responses/{id} - Retrieve a single response diff --git a/services/opensecret/src/web/responses/image_describer.rs b/services/opensecret/src/web/responses/image_describer.rs index 8e26670ec..f4aa78075 100644 --- a/services/opensecret/src/web/responses/image_describer.rs +++ b/services/opensecret/src/web/responses/image_describer.rs @@ -2,7 +2,7 @@ //! //! This module deliberately owns only provider-independent policy and wire-format //! construction. The handler supplies an [`ImageDescriptionAttemptExecutor`] -//! that routes each candidate through the request's V1 or V2 policy, accounts for +//! that routes each candidate through the request's cache policy, accounts for //! every provider response it consumes, and returns a bounded response body. use crate::model_config::model_config; diff --git a/services/opensecret/src/web/system_one.rs b/services/opensecret/src/web/system_one.rs index e421f9c59..fdbdb383d 100644 --- a/services/opensecret/src/web/system_one.rs +++ b/services/opensecret/src/web/system_one.rs @@ -1411,7 +1411,6 @@ impl Upstream<'_> { apply_provider_managed_request_fields( &mut body, &self.proxy.provider_name, - self.user.uuid, self.cache_policy, ); let payload = serde_json::to_vec(&Value::Object(body)).map_err(|e| { @@ -1817,7 +1816,6 @@ async fn system_one( &state, &user, auth_method, - &session_id, cache_namespace_root.map(|axum::Extension(root)| root), "system one", ) diff --git a/services/opensecret/src/web/system_one/decisions.rs b/services/opensecret/src/web/system_one/decisions.rs index 265bc1823..ac657b5f3 100644 --- a/services/opensecret/src/web/system_one/decisions.rs +++ b/services/opensecret/src/web/system_one/decisions.rs @@ -788,8 +788,13 @@ mod tests { crate::web::openai::apply_provider_managed_request_fields( &mut body, &proxy.provider_name, - uuid::Uuid::nil(), - &crate::web::openai::CompletionCachePolicy::LegacyV1, + &crate::web::openai::CompletionCachePolicy::for_request( + Some(crate::provider_cache::CacheNamespaceRoot::from_bytes( + [7; 32], + )), + uuid::Uuid::nil(), + ) + .unwrap(), ); let response = client .send( From 56aac72885d0ca771b386b86c44f2cd2d565db91 Mon Sep 17 00:00:00 2001 From: Anthony Ronning <101225832+AnthonyRonning@users.noreply.github.com> Date: Wed, 18 Nov 2026 13:22:52 -0800 Subject: [PATCH 2/3] OpenSecret: pin the gateway-only boundary and fail closed in OAuth Follow-ups from review of the Transport V1 removal. - A source invariant now walks every router under src/web and requires a transport-boundary layer on each handler of each application route. The existing invariant also pins how main() serves the listener and the exact routes of the four plaintext routers. - The OAuth redirect callback no longer has an exchange path without the PKCE verifier or a verification path without the Apple nonce: a missing binding is an internal error instead of a silent skip. - Refresh request types are no longer deserializable, since a refresh token only ever arrives as the envelope's resumption credential. - Drop the key_exchange diagnostics route class, rename the SSE event helper, and correct docs, comments and test names that still described per-session encryption. Co-Authored-By: Claude --- .agents/skills/change-opensecret-api/SKILL.md | 6 +- services/opensecret/README.md | 3 +- .../opensecret/docs/transport-v2-protocol.md | 6 +- services/opensecret/src/bounded_ttl_cache.rs | 43 +-- .../opensecret/src/security_invariants.rs | 302 +++++++++++++++++- .../src/transport_v2/diagnostics.rs | 1 - services/opensecret/src/web/login_routes.rs | 5 +- services/opensecret/src/web/oauth_routes.rs | 20 +- services/opensecret/src/web/openai.rs | 6 +- .../src/web/platform/login_routes.rs | 2 +- 10 files changed, 335 insertions(+), 59 deletions(-) diff --git a/.agents/skills/change-opensecret-api/SKILL.md b/.agents/skills/change-opensecret-api/SKILL.md index 255f551e3..bd78e7084 100644 --- a/.agents/skills/change-opensecret-api/SKILL.md +++ b/.agents/skills/change-opensecret-api/SKILL.md @@ -53,9 +53,9 @@ does not establish the selected inference router. require a live session. - JWT and API-key contexts are distinct. Preserve the auth method through authorization, persistence eligibility, quota, and usage attribution. -- Hold the session lease for the complete response body or stream. Successful - protected responses and ordinary stream events remain encrypted according to - the established client protocol. +- The gateway encrypts the complete logical response, including every stream + record and its terminal record. A handler returns ordinary JSON or SSE, and a + stream must end with an explicit terminal event. - Validate provider-free input before writes. Pinned clients may recover from selected session or auth failures by retrying, so a side-effecting change needs explicit idempotency or proof that validation precedes the effect. diff --git a/services/opensecret/README.md b/services/opensecret/README.md index a044db700..d8d0e75ec 100644 --- a/services/opensecret/README.md +++ b/services/opensecret/README.md @@ -49,8 +49,7 @@ protected environment variables. Billing and feature flags are optional external HTTP APIs whose administrative credentials remain in the backend; their server implementations are not part of this repository setup. -Protected routes require OpenSecret attestation/key exchange and encrypted -sessions. “OpenAI-shaped” describes decrypted payloads, not a plaintext +Protected routes require an attested Transport V2 session. “OpenAI-shaped” describes decrypted payloads, not a plaintext OpenAI-compatible wire endpoint. Use an OpenSecret SDK or Maple for protected-route integration tests; plain `curl` is suitable only for public health probes. diff --git a/services/opensecret/docs/transport-v2-protocol.md b/services/opensecret/docs/transport-v2-protocol.md index 14c48527b..59fcbcb7e 100644 --- a/services/opensecret/docs/transport-v2-protocol.md +++ b/services/opensecret/docs/transport-v2-protocol.md @@ -739,8 +739,10 @@ decrypt: only the gateway can attach the in-process session marker, and authentication reads only the credential the envelope carried, never an outer header. -A released V1 client fails at `POST /key_exchange`, which no longer exists, and -must be updated. V1 access and refresh tokens are accepted nowhere; a V2 client +A released V1 client can neither establish nor use a session and must be +updated: the attestation document carries no key, `POST /key_exchange` does not +exist, and a request it sends under a session it already held finds no route. +V1 access and refresh tokens are accepted nowhere; a V2 client authenticates afresh through login, registration, OAuth, or native handoff. Raw inference-only API keys are unaffected and are presented as an `api_key` credential. diff --git a/services/opensecret/src/bounded_ttl_cache.rs b/services/opensecret/src/bounded_ttl_cache.rs index df2265277..68a6c3ca1 100644 --- a/services/opensecret/src/bounded_ttl_cache.rs +++ b/services/opensecret/src/bounded_ttl_cache.rs @@ -43,7 +43,7 @@ where /// Inserts a new value, always admitting it. At capacity, an expired oldest /// entry is reclaimed first; otherwise the oldest live entry is evicted. - /// Duplicate keys retain the historical latest-request-wins behavior. + /// A duplicate key replaces its existing value. pub(crate) fn insert_evicting_at(&mut self, key: K, value: V, now: Instant) -> InsertOutcome { let expires_at = now .checked_add(self.ttl) @@ -108,8 +108,7 @@ where mod tests { use super::*; use std::sync::atomic::{AtomicUsize, Ordering}; - use std::sync::Arc; - use tokio::sync::RwLock; + use std::sync::{Arc, Mutex}; fn cache(capacity: usize, ttl: Duration) -> BoundedTtlCache where @@ -243,25 +242,27 @@ mod tests { assert_eq!(drops.load(Ordering::SeqCst), 4, "cache destruction"); } - #[tokio::test] - async fn actual_locking_pattern_never_exceeds_capacity() { - let cache = Arc::new(RwLock::new(cache(32, Duration::from_secs(300)))); - let mut tasks = Vec::new(); - - for key in 0..512 { - let cache = cache.clone(); - tasks.push(tokio::spawn(async move { - cache - .write() - .await - .insert_evicting_at(key, key, Instant::now()); - })); - } - - for task in tasks { - task.await.unwrap(); + #[test] + fn concurrent_inserts_under_a_mutex_never_exceed_capacity() { + let cache = Arc::new(Mutex::new(cache(32, Duration::from_secs(300)))); + let threads: Vec<_> = (0..8) + .map(|thread| { + let cache = cache.clone(); + std::thread::spawn(move || { + for key in (thread * 64)..((thread + 1) * 64) { + cache + .lock() + .unwrap() + .insert_evicting_at(key, key, Instant::now()); + } + }) + }) + .collect(); + + for thread in threads { + thread.join().unwrap(); } - assert_eq!(cache.read().await.len(), 32); + assert_eq!(cache.lock().unwrap().len(), 32); } #[test] diff --git a/services/opensecret/src/security_invariants.rs b/services/opensecret/src/security_invariants.rs index c747de8d9..bce63ac13 100644 --- a/services/opensecret/src/security_invariants.rs +++ b/services/opensecret/src/security_invariants.rs @@ -342,7 +342,7 @@ fn openai_compatible_routes_do_not_request_user_storage_keys() { } #[test] -fn models_route_allows_optional_identity_but_requires_session_e2ee() { +fn models_route_allows_optional_identity_but_requires_a_transport_session() { let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")); let main_source = fs::read_to_string(manifest_dir.join("src/main.rs")) .expect("main source should be readable"); @@ -360,7 +360,7 @@ fn models_route_allows_optional_identity_but_requires_session_e2ee() { router_body.contains("\"/v1/models\"") && router_body.contains("decrypt_request::<()>") && !router_body.contains("decrypt_models_request"), - "the models route must validate a live encryption session for every request" + "the models route must require the gateway's transport session for every request" ); let handler_body = extract_function_body(&openai_source, "async fn proxy_models"); @@ -369,16 +369,16 @@ fn models_route_allows_optional_identity_but_requires_session_e2ee() { "async fn proxy_models(\n State(state): State>,\n axum::Extension(session_id): axum::Extension,\n _user: Option>,\n)" ) && handler_body.contains("encrypt_response(&state, &session_id, &models_response)"), - "the models handler must require session E2EE" + "the models handler must require the transport session and answer through it" ); assert!( !handler_body.contains("Json(models_response)"), - "the models handler must not return a successful plaintext response" + "the models handler must not answer outside the transport response helper" ); } #[test] -fn openai_auth_remains_outside_session_decryption() { +fn openai_auth_remains_outside_request_body_parsing() { let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")); let main_source = fs::read_to_string(manifest_dir.join("src/main.rs")) .expect("main source should be readable"); @@ -386,9 +386,8 @@ fn openai_auth_remains_outside_session_decryption() { .expect("OpenAI route source should be readable"); // `route_layer` is applied when the completed OpenAI router is composed - // into the application, so it wraps the route-local decryption layers. - // This order lets a request with both an expired access token and a stale - // session receive the access-token refresh signal first. + // into the application, so it wraps the route-local body-parsing layers: + // a caller is authenticated before its request body is parsed. assert!( main_source.contains( "openai_routes(app_state.clone())\n .route_layer(from_fn_with_state(app_state.clone(), require_internal))\n .route_layer(from_fn_with_state(app_state.clone(), validate_openai_auth))" @@ -407,12 +406,12 @@ fn openai_auth_remains_outside_session_decryption() { let chat_route = &router_body[chat_route_start..next_route_start]; assert!( chat_route.contains("decrypt_request::"), - "chat completions must retain route-local session decryption" + "chat completions must retain its route-local transport boundary" ); } #[test] -fn web_routes_remain_jwt_authenticated_and_e2ee_wrapped() { +fn web_routes_remain_jwt_authenticated_behind_the_transport_boundary() { let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")); let main_source = fs::read_to_string(manifest_dir.join("src/main.rs")) .expect("main source should be readable"); @@ -430,7 +429,7 @@ fn web_routes_remain_jwt_authenticated_and_e2ee_wrapped() { assert_eq!( router_body.matches("decrypt_request::").count(), 2, - "both web routes must decrypt request bodies through session E2EE" + "both web routes must parse request bodies at the transport boundary" ); assert_eq!( web_source @@ -443,7 +442,7 @@ fn web_routes_remain_jwt_authenticated_and_e2ee_wrapped() { let handler_body = extract_function_body(&web_source, handler); assert!( handler_body.contains("encrypt_response(&state, &session_id, &response)"), - "{handler} must encrypt successful responses through session E2EE" + "{handler} must answer through the transport response helper" ); } } @@ -1575,6 +1574,235 @@ fn recovery_management_routes_require_jwt_and_encrypted_requests() { ); } +/// Routers the listener serves in plaintext by design. Every other router +/// under `src/web` belongs to the application. +const PLAINTEXT_ROUTER_SOURCES: &[&str] = &[ + "src/web/attestation_routes.rs", + "src/web/health_routes.rs", + "src/web/remote/relay.rs", +]; + +/// Middleware that refuses a request without the gateway's transport session +/// before its handler can run. +const TRANSPORT_BOUNDARY_MIDDLEWARE: &[&str] = &[ + "decrypt_request", + "prepare_refresh_request", + "prepare_platform_refresh_request", +]; + +const ROUTE_METHODS: &[&str] = &["get", "post", "put", "patch", "delete"]; + +/// Each handler on each application route carries its own transport-boundary +/// layer, so a router mounted in the wrong place still fails closed. +#[test] +fn every_application_route_enforces_the_transport_boundary() { + let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")); + let mut scan = RouteBoundaryScan::default(); + scan_route_boundaries(&manifest_dir.join("src/web"), manifest_dir, &mut scan); + + assert!( + scan.findings.is_empty(), + "application routes without a transport boundary on every handler:\n{}", + scan.findings.join("\n") + ); + // Guard the scan itself: an empty walk would pass vacuously. + assert!( + scan.handlers >= 100, + "expected to scan the application's routes, found only {} handlers", + scan.handlers + ); +} + +#[test] +fn route_boundary_scanner_flags_unlayered_and_partially_layered_routes() { + let source = r#" +fn router(state: S) -> Router { + Router::new() + .route("/covered", post(a).layer(from_fn_with_state(state.clone(), decrypt_request::))) + .route("/refresh", post(b).layer(from_fn(prepare_refresh_request))) + .route("/bare", get(c)) + .route( + "/half", + get(d) + .layer(from_fn_with_state(state.clone(), decrypt_request::<()>)) + .merge(post(e)), + ) + .route("/chained", get(f).delete(g).layer(from_fn(decrypt_request::<()>))) +} + +#[cfg(test)] +mod tests { + fn test_router() -> Router { + Router::new().route("/test-only", get(h)) + } +} +"#; + let mut scan = RouteBoundaryScan::default(); + scan_route_boundary_source("example.rs", source, &mut scan); + + assert_eq!(scan.handlers, 7); + assert_eq!(scan.findings.len(), 3, "{:?}", scan.findings); + for route in ["/bare", "/half", "/chained"] { + assert!( + scan.findings.iter().any(|finding| finding.contains(route)), + "{route} should be reported: {:?}", + scan.findings + ); + } +} + +#[derive(Default)] +struct RouteBoundaryScan { + handlers: usize, + findings: Vec, +} + +fn scan_route_boundaries(path: &Path, manifest_dir: &Path, scan: &mut RouteBoundaryScan) { + if path.is_dir() { + for entry in fs::read_dir(path).expect("source directory should be readable") { + let entry = entry.expect("source directory entry should be readable"); + scan_route_boundaries(&entry.path(), manifest_dir, scan); + } + return; + } + if path.extension().and_then(|extension| extension.to_str()) != Some("rs") { + return; + } + // Out-of-line test modules (`tests.rs`, `*_tests.rs`) carry no `cfg(test)` + // attribute of their own. + let stem = path + .file_stem() + .and_then(|stem| stem.to_str()) + .unwrap_or(""); + if stem == "tests" || stem.ends_with("_tests") { + return; + } + let relative_path = path + .strip_prefix(manifest_dir) + .unwrap_or(path) + .display() + .to_string(); + if PLAINTEXT_ROUTER_SOURCES.contains(&relative_path.as_str()) { + return; + } + let contents = fs::read_to_string(path) + .unwrap_or_else(|_| panic!("{} should be readable", path.display())); + scan_route_boundary_source(&relative_path, &contents, scan); +} + +fn scan_route_boundary_source(source_path: &str, source: &str, scan: &mut RouteBoundaryScan) { + let syntax = syn::parse_file(source) + .unwrap_or_else(|error| panic!("{source_path} should parse as Rust source: {error}")); + let mut visitor = RouteBoundaryVisitor { source_path, scan }; + visitor.visit_file(&syntax); +} + +fn is_test_only(attrs: &[syn::Attribute]) -> bool { + attrs.iter().any(|attr| { + attr.path().is_ident("test") + || (attr.path().is_ident("cfg") + && attr + .parse_args::() + .is_ok_and(|ident| ident == "test")) + }) +} + +fn last_path_ident(expr: &syn::Expr) -> Option { + match expr { + syn::Expr::Path(path) => path + .path + .segments + .last() + .map(|segment| segment.ident.to_string()), + _ => None, + } +} + +/// `get(handler)`, optionally followed by layers, merges, or further methods. +fn is_method_router(expr: &syn::Expr) -> bool { + match expr { + syn::Expr::Call(call) => { + last_path_ident(&call.func).is_some_and(|name| ROUTE_METHODS.contains(&name.as_str())) + } + syn::Expr::MethodCall(call) => is_method_router(&call.receiver), + _ => false, + } +} + +struct RouteBoundaryVisitor<'a> { + source_path: &'a str, + scan: &'a mut RouteBoundaryScan, +} + +impl<'ast> Visit<'ast> for RouteBoundaryVisitor<'_> { + fn visit_item_mod(&mut self, item: &'ast syn::ItemMod) { + if !is_test_only(&item.attrs) { + visit::visit_item_mod(self, item); + } + } + + fn visit_item_fn(&mut self, item: &'ast syn::ItemFn) { + if !is_test_only(&item.attrs) { + visit::visit_item_fn(self, item); + } + } + + fn visit_expr_method_call(&mut self, call: &'ast syn::ExprMethodCall) { + if call.method == "route" && call.args.len() == 2 { + let mut counter = RouteHandlerCounter::default(); + counter.visit_expr(&call.args[1]); + self.scan.handlers += counter.handlers; + if counter.handlers == 0 || counter.boundaries < counter.handlers { + let route = match &call.args[0] { + syn::Expr::Lit(syn::ExprLit { + lit: syn::Lit::Str(route), + .. + }) => route.value(), + _ => "".to_string(), + }; + self.scan.findings.push(format!( + "{}: route {route} has {} handler(s) and {} transport boundary layer(s)", + self.source_path, counter.handlers, counter.boundaries + )); + } + } + visit::visit_expr_method_call(self, call); + } +} + +#[derive(Default)] +struct RouteHandlerCounter { + handlers: usize, + boundaries: usize, +} + +impl<'ast> Visit<'ast> for RouteHandlerCounter { + fn visit_expr_call(&mut self, call: &'ast syn::ExprCall) { + if is_method_router(&syn::Expr::Call(call.clone())) { + self.handlers += 1; + } + visit::visit_expr_call(self, call); + } + + fn visit_expr_method_call(&mut self, call: &'ast syn::ExprMethodCall) { + if ROUTE_METHODS.contains(&call.method.to_string().as_str()) + && is_method_router(&call.receiver) + { + self.handlers += 1; + } + visit::visit_expr_method_call(self, call); + } + + fn visit_expr_path(&mut self, path: &'ast syn::ExprPath) { + if path.path.segments.last().is_some_and(|segment| { + TRANSPORT_BOUNDARY_MIDDLEWARE.contains(&segment.ident.to_string().as_str()) + }) { + self.boundaries += 1; + } + visit::visit_expr_path(self, path); + } +} + /// The listener serves the application only through the Transport V2 gateway. /// A router that mounted an application route directly would hand a plaintext /// HTTP caller a route whose handlers assume an authenticated, decrypted @@ -1635,10 +1863,58 @@ fn application_routes_are_served_only_behind_the_transport_v2_gateway() { &[ "TransportV2Gateway::new(", "transport_v2_application(app_state.clone())", - "public_routes(app_state.clone(), &transport_v2_gateway)", + "let app = public_routes(app_state.clone(), &transport_v2_gateway)\n .layer(cors)\n .layer(from_fn(add_error_contract_header));", "axum::serve(listener, app.into_make_service())", ], ); + for forbidden_pattern in [".merge(", ".nest(", ".route(", ".fallback("] { + assert!( + !main_body.contains(forbidden_pattern), + "main must serve public_routes as built, without `{forbidden_pattern}`" + ); + } + + // Each plaintext router serves exactly the routes it is named for. + for (path, signature, routes) in [ + ( + "src/web/health_routes.rs", + "pub fn router", + &["\"/health-check\""][..], + ), + ( + "src/web/attestation_routes.rs", + "pub fn router", + &["\"/attestation/:nonce\""][..], + ), + ( + "src/web/remote/relay.rs", + "pub(crate) fn router", + &["\"/v1/remote/relay-access\""][..], + ), + ( + "src/transport_v2/gateway.rs", + "pub(crate) fn router", + &["\"/v2/session\"", "\"/v2/request\""][..], + ), + ] { + let source = fs::read_to_string(Path::new(env!("CARGO_MANIFEST_DIR")).join(path)) + .expect("router source should be readable"); + let router_body = extract_function_body(&source, signature); + assert_eq!( + router_body.matches(".route(").count(), + routes.len(), + "{path} must serve exactly {routes:?}" + ); + for route in routes { + assert!(router_body.contains(route), "{path} must serve {route}"); + } + for forbidden_pattern in [".merge(application", ".nest(", ".fallback("] { + assert!( + !router_body.contains(forbidden_pattern), + "{path} must not widen its router with `{forbidden_pattern}`" + ); + } + } // The application's own boundary fails closed without the gateway's // session marker, and its authentication reads only envelope credentials. diff --git a/services/opensecret/src/transport_v2/diagnostics.rs b/services/opensecret/src/transport_v2/diagnostics.rs index f115a0027..d67dbb618 100644 --- a/services/opensecret/src/transport_v2/diagnostics.rs +++ b/services/opensecret/src/transport_v2/diagnostics.rs @@ -37,7 +37,6 @@ const ROUTE_CLASSES: &[(&[&str], &str)] = &[ (&["health-check"], "health_check"), (&["ok"], "ok"), (&["attestation"], "attestation"), - (&["key_exchange"], "key_exchange"), (&["protected"], "protected"), (&["login"], "login"), (&["logout"], "login"), diff --git a/services/opensecret/src/web/login_routes.rs b/services/opensecret/src/web/login_routes.rs index 84f251b65..45b63fde0 100644 --- a/services/opensecret/src/web/login_routes.rs +++ b/services/opensecret/src/web/login_routes.rs @@ -208,7 +208,7 @@ pub struct AuthResponse { pub refresh_token: String, } -#[derive(Deserialize, Clone)] +#[derive(Clone)] pub struct RefreshRequest { refresh_token: String, } @@ -838,8 +838,7 @@ pub async fn password_reset_v2_complete( } }; - // Tokens are bound to the new password credential, matching the session - // transport the completion arrived on. + // Tokens are bound to the new password credential. let access_token = NewToken::new_with_auth_context( &user, TokenType::TransportV2Access, diff --git a/services/opensecret/src/web/oauth_routes.rs b/services/opensecret/src/web/oauth_routes.rs index 1a4b60e87..a37420c7d 100644 --- a/services/opensecret/src/web/oauth_routes.rs +++ b/services/opensecret/src/web/oauth_routes.rs @@ -854,13 +854,10 @@ pub async fn oauth_callback( error!("Failed to build OAuth HTTP client: {:?}", e); ApiError::InternalServerError })?; - let exchange = - oauth_client.exchange_code(AuthorizationCode::new(callback_request.code.clone())); - let exchange = if let Some(verifier) = pkce_verifier { - exchange.set_pkce_verifier(verifier) - } else { - exchange - }; + // The code is exchanged only with this session's PKCE verifier. + let exchange = oauth_client + .exchange_code(AuthorizationCode::new(callback_request.code.clone())) + .set_pkce_verifier(pkce_verifier.ok_or(ApiError::InternalServerError)?); let token = exchange.request_async(&http_client).await.map_err(|e| { match &e { // The raw body may hold tokens; log only where parsing failed. @@ -997,7 +994,10 @@ pub async fn oauth_callback( &app_state, &id_token, &client_id, - apple_nonce.as_ref().map(|nonce| nonce.as_str()), + apple_nonce + .as_ref() + .ok_or(ApiError::InternalServerError)? + .as_str(), ) .await { @@ -1181,7 +1181,7 @@ async fn fetch_apple_user( app_state: &AppState, id_token: &str, client_id: &str, - expected_nonce: Option<&str>, + expected_nonce: &str, ) -> Result { debug!("Parsing and validating Apple ID token"); @@ -1191,7 +1191,7 @@ async fn fetch_apple_user( &app_state.apple_jwt_verifier, id_token, client_id, - expected_nonce, + Some(expected_nonce), ) .await?; diff --git a/services/opensecret/src/web/openai.rs b/services/opensecret/src/web/openai.rs index 6efbabf8c..346aaf5eb 100644 --- a/services/opensecret/src/web/openai.rs +++ b/services/opensecret/src/web/openai.rs @@ -3608,7 +3608,7 @@ async fn encrypt_sse_event( _transport_session: &TransportSession, json: &Value, ) -> Result { - Ok(sse_event_from_encoded_data(&json.to_string())) + Ok(sse_data_event(&json.to_string())) } /// OpenAI-style error payload for encrypted in-stream failures. Clients @@ -3639,7 +3639,7 @@ fn completion_failure_payload(failure: &AttemptFailure) -> Value { } } -fn sse_event_from_encoded_data(event_data: &str) -> Event { +fn sse_data_event(event_data: &str) -> Event { Event::default().data(event_data) } @@ -6168,7 +6168,7 @@ mod tests { let payload = completion_error_payload("Inference provider request failed"); let plaintext = payload.to_string(); - let event = sse_event_from_encoded_data(&plaintext); + let event = sse_data_event(&plaintext); let response = Sse::new(futures::stream::iter([Ok::(event)])).into_response(); let body = to_bytes(response.into_body(), 4096) diff --git a/services/opensecret/src/web/platform/login_routes.rs b/services/opensecret/src/web/platform/login_routes.rs index b6167d38e..311c94f34 100644 --- a/services/opensecret/src/web/platform/login_routes.rs +++ b/services/opensecret/src/web/platform/login_routes.rs @@ -70,7 +70,7 @@ pub struct PlatformAuthResponse { pub refresh_token: String, } -#[derive(Deserialize, Clone, Validate)] +#[derive(Clone, Validate)] pub struct PlatformRefreshRequest { #[validate(length(min = 1, message = "Refresh token cannot be empty"))] pub refresh_token: String, From 1a935b3b7158f9042d00f1677d16335c8180f25c Mon Sep 17 00:00:00 2001 From: Anthony Ronning <101225832+AnthonyRonning@users.noreply.github.com> Date: Thu, 19 Nov 2026 11:54:40 -0800 Subject: [PATCH 3/3] OpenSecret: update the uncensored Kimi route test for the cache policy The test arrived on master after this branch was cut and still built the cache policy through the variant and the user argument this branch removes, so the rebased branch did not compile its tests. Co-Authored-By: Claude --- services/opensecret/src/web/openai/maple_tests.rs | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/services/opensecret/src/web/openai/maple_tests.rs b/services/opensecret/src/web/openai/maple_tests.rs index 064887997..7c7810cfd 100644 --- a/services/opensecret/src/web/openai/maple_tests.rs +++ b/services/opensecret/src/web/openai/maple_tests.rs @@ -142,7 +142,7 @@ fn uncensored_kimi_route_sends_its_own_model_name_and_bills_the_maple_family() { let user = Uuid::from_u128(17); let model = crate::model_config::KIMI_K3_1_PRO_UNCENSORED_MODEL_ID; assert_eq!(model, "kimi-k3-1-pro-uncensored"); - let cache = CompletionCachePolicy::BoundV2(derive_provider_cache_namespaces( + let cache = CompletionCachePolicy(derive_provider_cache_namespaces( &CacheNamespaceRoot::from_bytes([0x42; 32]), user, )); @@ -201,21 +201,14 @@ fn uncensored_kimi_route_sends_its_own_model_name_and_bills_the_maple_family() { .unwrap() .clone(); body.insert("model".to_owned(), json!(route.provider_model_id)); - apply_provider_managed_request_fields( - &mut body, - route.provider.family_name(), - user, - &cache, - ); + apply_provider_managed_request_fields(&mut body, route.provider.family_name(), &cache); ensure_stream_usage(&mut body); let mut body = Value::Object(body); assert!(route.provider.is_maple()); crate::maple_inference::sanitize_completion_request(&mut body); assert_eq!(body["model"], "kimi-k3-1-pro-uncensored"); - let CompletionCachePolicy::BoundV2(namespaces) = &cache else { - unreachable!(); - }; + let CompletionCachePolicy(namespaces) = &cache; assert_eq!( body["cache_salt"], json!(namespaces.maple_user_cache_secret())