3 Commits

Author	SHA1	Message	Date
Dragan Spiridonov	31fb3d53f6	feat(cli): wifi-densepose login — Cognitum sign-in (ADR-271 phase 2) ... Phase 1 could verify a token and phase 3 could gate on one, but there was no way for a user to OBTAIN one. This closes that: sign in with a Cognitum account and get a token a RuView sensing server accepts, instead of everyone sharing one static RUVIEW_API_TOKEN string. Lives in `ruview-auth` behind a non-default `login` feature rather than in the CLI, so the Tauri desktop app can reuse it instead of growing a second copy. A server built with default features still gets the verifier and nothing else — no reqwest, no tokio net, no browser launcher. (This amends ADR-271's "no login flow in this crate" note; the reason for that line was to keep the server lean, and a feature gate achieves it without duplication.) Ported from meta-proxy's src/oauth/, cross-checked against musica's cognitum_provider.rs — two independent implementations against this same AS. Where they agree, this follows both: redirect path EXACTLY /oauth/callback, 60-second refresh skew, OOB fallback on SSH/CONTAINER//.dockerenv. Refresh is the part with teeth. Identity rotates refresh tokens with reuse detection, so presenting a spent one revokes the whole session family. Both obvious implementations are wrong: refreshing concurrently looks like replay, and retrying a failed refresh with the same token IS the replay. So `Session::ensure_fresh` holds an async mutex across the await, re-checks expiry after acquiring it (the waiter usually finds the work already done), persists the rotated token BEFORE returning it, and never retries. A missing expires_at counts as expired rather than being given a guessed default. Least scope by default: `login` requests `sensing:read`. `--admin` adds `sensing:admin` explicitly, and requests both because there is no scope hierarchy server-side. A session that streams poses should not casually hold the capability to delete the model it streams through. Credentials are written atomically and 0600 (temp file, chmod BEFORE rename) — the same discipline the seed applies to its cloud key. `logout` is local-only and says so: it makes this machine unable to act as you, but revoking the session everywhere is an account-level action. Also `whoami`, which reports whether the stored token is live — an expired-looking session is the most common reason a command starts 401ing, and it should be visible directly rather than inferred from a failure elsewhere. Verified against PRODUCTION, not just locally: authorize URLs built by this exact code path return HTTP 200 from auth.cognitum.one for both `sensing:read` and `sensing:read sensing:admin`, which exercises the real client_id, scope encoding, PKCE parameters and redirect_uri shape. Tests: 74 with --features login (51 unit + 21 verifier matrix + 2 doctests), including the RFC 7636 Appendix B vector, multi-scope URL encoding (a space that is hand-formatted rather than encoded silently truncates the request), a real TCP callback round-trip, callback timeout, 0600 permissions asserted on disk, atomic-save leaving no temp file, and refresh-window boundaries. Unchanged: 43 with default features, 501 in the sensing server. Co-Authored-By: Ruflo & AQE	2026-07-22 17:53:42 +02:00
Dragan Spiridonov	c2bd33e649	feat(sensing-server): accept Cognitum OAuth on /api/v1/*, scope-gated (ADR-271 phase 3) ... Wires `ruview-auth` into `bearer_auth.rs`. `RUVIEW_OAUTH_ISSUER` enables it; unset, nothing changes. Layering, in order: 1. `RUVIEW_API_TOKEN` set and the bearer matches exactly -> allow. Byte-for- byte today's behaviour. 2. Otherwise, if OAuth is configured, verify the bearer as a Cognitum access token and require the scope the route needs. 3. Otherwise 401. The static compare goes first for compatibility, not security: a matching static token is not a JWT and a JWT never matches the static token. It means an existing deployment behaves identically even with OAuth switched on. Scope gate (`required_scope_for`), split by blast radius per ADR-060 — "can this destroy something", not how many routes it covers: sensing:admin /api/v1/train/* (hours of Pi CPU, writes models) DELETE /api/v1/models/{id} (irreversible) DELETE /api/v1/recording/{id} (irreversible) sensing:read everything else Deliberately NOT admin: model load/unload and recording start. They mutate server state but destroy nothing, and gating them would push routine dashboard use into requesting delete capability — the opposite of least privilege. The legacy static token stays un-scope-gated. It predates scopes and carries no claims, so narrowing it would be a silent breaking change to deployments using it; migrating to OAuth is how an operator opts into the finer split. FAIL CLOSED at boot. If OAuth is requested but cannot work — empty issuer, or a JWKS we cannot fetch — the server logs why and exits rather than serving. Starting anyway would silently downgrade an operator who asked for OAuth to either an open API or a shared-secret one, with no signal it happened. The JWKS is warmed eagerly for the same reason: a bad `jwks_uri` should die at boot with a legible message, not surface as a puzzling 401 an hour later. The verified `Principal` is attached to request extensions, so handlers and audit logs can attribute a request (`sub`, `account_id`, `org_id`, `workspace_id`, `jti`) instead of knowing only "someone had the secret". That is the point of moving off a shared bearer. Verification failures are logged with the reason and returned as a flat 401 — the reason is useful to an operator and equally useful to an attacker probing for which claim to forge next. Also aligns `ruview_auth::extract_bearer` to match the scheme case-insensitively (RFC 7235 §2.1). The sensing server has always done this deliberately, with a comment saying why; the two layers disagreeing about what a valid header looks like would be a latent bug. Tests: 16 new in `bearer_auth::oauth_tests`, driving a real Router end to end (request -> middleware -> verifier -> handler) with ES256 tokens signed by a runtime-generated key. Covers the scope policy as a pure function, read-scoped tokens refused on delete and train, admin-scoped tokens allowed, an `inference`-only token from another Cognitum product refused on every route, garbage and absent bearers, both legacy-token layering directions, the principal reaching a handler, and the unset case remaining a no-op. `cargo test -p wifi-densepose-sensing-server --lib --no-default-features`: 501 passed, 0 failed. `ruview-auth`: 43 passed across both feature configs. Co-Authored-By: Ruflo & AQE	2026-07-22 15:33:22 +02:00
Dragan Spiridonov	499cec7914	feat(auth): ruview-auth — offline Cognitum OAuth access-token verification (ADR-271) ... RuView's `/api/v1/*` is gated today by `RUVIEW_API_TOKEN`: one shared secret, no expiry, no per-user attribution. This adds the verifier half of replacing that with Cognitum identity — RuView as an OAuth **resource server**, so a user signs in to their own sensing server with their Cognitum account. Note the direction: RuView does not call Cognitum. It never obtains a token for its own use; it verifies tokens users present. Every other Cognitum OAuth integration in the org (meta-proxy, musica, metaharness, the dashboard CLI) is the client side of a plane RuView doesn't have. The one existing resource-server verifier is `meta-llm/src/auth/oauthBearer.ts`, and this crate is a port of its accept-rule — divergence would be a bug, not a preference: a token meta-llm rejects must not be one RuView accepts. Verification is OFFLINE, and that is a requirement rather than an optimisation. RuView runs on Pi-class hardware that loses WAN, and identity publishes no introspection endpoint even when the network is up. So: ES256 over identity's published JWKS, cached by `kid`. What it accepts, mirroring oauthBearer.ts: typ == "access" AND NOT setup AND NOT workload AND account_id non-empty AND exp in the future AND iss matches verbatim AND the required scope is held. Long-lived setup (365-day) and workload credentials are refused outright for identity's own stated reason: their revocation lives in `oauth_setup_tokens`, and RuView — like meta-llm — has no database to check it. A 15-minute access token needs no revocation round-trip because it expires faster than revocation propagates; a 365-day one does. Scope is the capability boundary, and it has to be. Cognitum access tokens carry no `aud`, and `client_id` cannot substitute because clients borrow each other's registrations (musica ships DEFAULT_CLIENT_ID = "meta-proxy"). `sensing:read` covers streams and inference; `sensing:admin` covers training, model delete and recording delete. No hierarchy — admin does not imply read; consent means what it said. Registered in identity migration 0016 (cognitum-one/dashboard#116). Design notes: - `ureq`, not `reqwest`: the sensing server deliberately chose ureq as "the smallest" HTTP client, and pulling reqwest in here would reverse that for the whole graph. Transport sits behind a `JwksFetcher` trait, so a host can supply its own and take no HTTP dependency at all (feature `ureq-transport`, default). - A JWKS refetch failure is survivable while a key set is already cached: a key that verified a minute ago has not stopped being valid because the network blipped, and failing closed there logs every user out of their own sensing server whenever their internet wobbles. We fail closed in exactly one case — no key set has ever been fetched. - Unknown `kid` forces one refetch so rotation is picked up without waiting out the TTL, rate-limited so junk-kid tokens can't become a request amplifier aimed at identity. - Expiry is reported distinctly from a bad signature: on an RTC-less Pi that is usually a clock-sync fault, and an operator must be able to tell them apart. - Test keypairs are generated at runtime, never committed. This repo tracks zero `.pem` files and committed key material shouldn't start here — it also means no fixture can drift out of sync with the JWKS it's served by. Tests: 41 green (19 unit + 21 matrix + 1 doctest) under BOTH `cargo test --no-default-features` (the repo's canonical gate) and default features. The matrix signs real ES256 tokens rather than asserting on strings, and covers alg:none, forged signature, spliced payload, unknown kid, expired, leeway boundaries both sides, wrong issuer, issuer differing only by a trailing slash, missing/!=access typ, setup and workload smuggled onto typ=access, missing and empty account_id, and scope escalation. The highest-value case is `g2_a_genuinely_valid_token_from_another_cognitum_ product_cannot_reach_the_sensing_surface`: a correctly signed, unexpired, right-issuer, right-typ token with client_id=meta-proxy and scope=inference is rejected. Nothing about its signature or identity claims distinguishes it — only scope does. A naive verifier accepts it, and an `inference` token becomes a key to someone's home sensor. No wiring into the sensing server yet; this crate is verification only, with no login flow and no outbound Cognitum calls. Co-Authored-By: Ruflo & AQE	2026-07-22 15:08:40 +02:00