diff options
| author | Pjotr Prins <pjotr.public01@thebird.nl> | 2026-11-14 14:20:54 +0000 |
|---|---|---|
| committer | Pjotr Prins <pjotr.public01@thebird.nl> | 2026-11-14 14:20:54 +0000 |
| commit | 586b0f63ef31fde987e00a305e91ee4e2136332e (patch) | |
| tree | 47eea9436d52d4634023b053f99049fa3ff21f39 /tests | |
| parent | c822ba22ce00c1615bf47fc8a13f28590aba424a (diff) | |
| download | genenetwork4-586b0f63ef31fde987e00a305e91ee4e2136332e.tar.gz | |
tokens: short opaque API tokens in a single tokens.sqlite
A second credential format beside gn-auth's JWT, for agents and scripts:
`gn4ai_` + 56 body characters + 2 checksum characters = 64, from an
alphabet with no look-alikes, so a typo is refused before the registry is
consulted. Opaque by design -- nothing is stored in the token; every fact
lives in one SQLite database (`tokens.sqlite`, GN4_API_TOKENS_DB, mode
0600, gitignored) keyed by the SHA-256 of the secret. Revoking is a row,
takes effect on the next request, and a token in a log line reveals
nothing; lose the registry and every short token stops working.
Administration is local-only: GET/POST /tokens, DELETE /tokens/{id} and
GET /tokens/who are behind a router layer that refuses any caller whose
TCP peer is not 127.x.x.x/::1, and any request claiming to come through a
proxy. A layer rather than a per-handler check, so nothing of a remote
request is parsed before it is refused; there is no configuration switch,
because minting credentials must never be reachable from the network.
A short token reads public data only: every token-only endpoint, and
`#[gnauth(secured)]` endpoints for public rows; a confidential dataset is
refused with a 403 that names the JWT route, since gn-auth cannot validate
an opaque token (the on-the-fly-bridge and registry-grant alternatives
were both rejected for v1).
scripts/gn4-token.py create|list|revoke|who drives the routes, so there is
one implementation of the format and the revocation rules; the token is
printed exactly once.
Tests: the localhost guard over all four routes (remote peer, no peer,
proxied header), and mint -> authenticate -> who -> revoke -> 401.
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/tokens.rs | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/tests/tokens.rs b/tests/tokens.rs new file mode 100644 index 0000000..f751c0b --- /dev/null +++ b/tests/tokens.rs @@ -0,0 +1,200 @@ +//! Token administration (`/tokens`, `/tokens/who`) answers only a caller +//! on this machine, and mints a token whose secret is shown exactly once +//! (src/routes/tokens.rs, src/tokens.rs). +//! +//! The peer address is the `ConnectInfo` a real server provides +//! (src/main.rs); these in-process requests supply one the same way +//! tests/get_test_token.rs does. The registry is a throwaway SQLite file +//! under the temp dir, wired in through `GN4_API_TOKENS_DB` before the +//! first `Config::load()` in this process. + +use axum::body::Body; +use axum::extract::ConnectInfo; +use axum::http::{Method, Request, StatusCode}; +use http_body_util::BodyExt; +use serde_json::{Value, json}; +use std::net::SocketAddr; +use std::sync::OnceLock; +use tower::ServiceExt; + +fn registry_path() -> &'static str { + static PATH: OnceLock<String> = OnceLock::new(); + PATH.get_or_init(|| { + let path = std::env::temp_dir().join(format!("gn4-tokens-it-{}.sqlite", std::process::id())); + let _ = std::fs::remove_file(&path); + let path = path.to_string_lossy().into_owned(); + // SAFETY: set before any request in this test binary has loaded the + // configuration, and to one value for the whole process, so no other + // thread can observe a different one. `set_var` is unsafe on edition + // 2024 because a concurrent reader could see a torn value; the + // OnceLock makes this the only write. + unsafe { std::env::set_var("GN4_API_TOKENS_DB", &path) }; + path + }) +} + +/// A request against the app, from `peer`, optionally with a JSON body. +async fn call( + method: Method, + uri: &str, + peer: Option<SocketAddr>, + body: Option<Value>, +) -> axum::response::Response { + let mut builder = Request::builder().method(method).uri(uri); + if body.is_some() { + builder = builder.header("content-type", "application/json"); + } + let mut request = builder + .body(match body { + Some(body) => Body::from(body.to_string()), + None => Body::empty(), + }) + .unwrap(); + if let Some(peer) = peer { + request.extensions_mut().insert(ConnectInfo(peer)); + } + genenetwork4::app().oneshot(request).await.unwrap() +} + +async fn error_of(response: axum::response::Response) -> Value { + let body = response.into_body().collect().await.unwrap().to_bytes(); + serde_json::from_slice(&body).unwrap() +} + +async fn json_of(response: axum::response::Response) -> Value { + let body = response.into_body().collect().await.unwrap().to_bytes(); + serde_json::from_slice(&body).unwrap() +} + +#[tokio::test] +async fn token_administration_refuses_every_caller_that_is_not_local() { + registry_path(); + let remote: SocketAddr = "10.0.0.5:4000".parse().unwrap(); + let local: SocketAddr = "127.0.0.1:4000".parse().unwrap(); + + // Every route, from another machine, and from a local caller that says it + // came through a proxy: minting a credential must never be reachable. + for (method, uri, body) in [ + (Method::GET, "/tokens", None), + ( + Method::POST, + "/tokens", + Some(json!({"id": "x-1", "subject": "x"})), + ), + (Method::DELETE, "/tokens/x-1", None), + (Method::GET, "/tokens/who", None), + ] { + let response = call(method.clone(), uri, Some(remote), body.clone()).await; + assert_eq!(response.status(), StatusCode::FORBIDDEN, "{method} {uri} remote"); + let error = error_of(response).await; + assert_eq!(error["code"], "not_local", "{method} {uri}"); + assert!(error["detail"].as_str().unwrap_or_default().contains("this machine")); + + // Fail closed with no peer at all. + let response = call(method.clone(), uri, None, body.clone()).await; + assert_eq!(response.status(), StatusCode::FORBIDDEN, "{method} {uri} no peer"); + + // A local peer whose request claims to be proxied: a reverse proxy on + // this host would make every remote client look local. + let request = Request::builder() + .method(method.clone()) + .uri(uri) + .header("x-forwarded-for", "203.0.113.9") + .body(Body::empty()) + .unwrap(); + let mut request = request; + request.extensions_mut().insert(ConnectInfo(local)); + let response = genenetwork4::app().oneshot(request).await.unwrap(); + assert_eq!(response.status(), StatusCode::FORBIDDEN, "{method} {uri} proxied"); + } +} + +#[tokio::test] +async fn a_token_minted_locally_authenticates_and_is_then_revoked() { + registry_path(); + let local: SocketAddr = "127.0.0.1:4000".parse().unwrap(); + + let response = call( + Method::POST, + "/tokens", + Some(local), + Some(json!({ + "id": "it-1", + "subject": "zachs", + "scope": "public", + "ttl_days": 7, + "note": "integration test" + })), + ) + .await; + assert_eq!(response.status(), StatusCode::OK); + let reply = json_of(response).await; + let token = reply["token"].as_str().expect("the secret, once").to_string(); + assert!(token.starts_with("gn4ai_"), "{token}"); + assert_eq!(token.len(), 64, "{token}"); + assert_eq!(reply["id"], "it-1"); + assert_eq!(reply["status"], "active"); + + // The listing never repeats the secret or its hash. + let response = call(Method::GET, "/tokens", Some(local), None).await; + let listing = json_of(response).await; + let listing_text = listing.to_string(); + assert!(!listing_text.contains(&token), "the listing leaked the token"); + assert!(!listing_text.contains("sha256")); + assert_eq!(listing["tokens"][0]["id"], "it-1"); + + // A second mint with the same id is a conflict, not a server error. + let response = call( + Method::POST, + "/tokens", + Some(local), + Some(json!({"id": "it-1", "subject": "zachs"})), + ) + .await; + assert_eq!(response.status(), StatusCode::CONFLICT); + + // The token works as a credential: /tokens/who describes it (it is the + // only route that needs no model access to prove the extractor branch). + let response = call_with_bearer(Method::GET, "/tokens/who", local, &token).await; + assert_eq!(response.status(), StatusCode::OK); + let who = json_of(response).await; + assert_eq!(who["scheme"], "opaque"); + assert_eq!(who["subject"], "zachs"); + assert_eq!(who["id"], "it-1"); + assert!(who["created_at"].as_i64().is_some()); + + // Revoking takes effect on the next request, with no restart. + let response = call(Method::DELETE, "/tokens/it-1", Some(local), None).await; + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json_of(response).await["status"], "revoked"); + + let response = call_with_bearer(Method::GET, "/tokens/who", local, &token).await; + assert_eq!(response.status(), StatusCode::UNAUTHORIZED); + + // A typo is refused as unmintable, before any registry lookup, and + // says so the same way as an unknown-but-well-formed token: the answer + // must not distinguish "not ours" from "no such token" to a caller. + let mut typo = token.clone().into_bytes(); + typo[10] = if typo[10] == b'a' { b'b' } else { b'a' }; + let typo = String::from_utf8(typo).unwrap(); + for candidate in [typo, "gn4ai_".to_string() + &"z".repeat(60), "not-a-token".to_string()] { + let response = call_with_bearer(Method::GET, "/tokens/who", local, &candidate).await; + assert_eq!(response.status(), StatusCode::UNAUTHORIZED, "{candidate}"); + } +} + +async fn call_with_bearer( + method: Method, + uri: &str, + peer: SocketAddr, + token: &str, +) -> axum::response::Response { + let mut request = Request::builder() + .method(method) + .uri(uri) + .header("authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(); + request.extensions_mut().insert(ConnectInfo(peer)); + genenetwork4::app().oneshot(request).await.unwrap() +} |
