diff options
| author | Pjotr Prins <pjotr.public01@thebird.nl> | 2026-11-14 15:10:28 +0000 |
|---|---|---|
| committer | Pjotr Prins <pjotr.public01@thebird.nl> | 2026-11-14 15:10:28 +0000 |
| commit | 6daec6b5d03a80af3e2496b6bf666340b3d718fd (patch) | |
| tree | 842d614ba0a5cdd72473ea0d96eb061fd8fef0f5 /src | |
| parent | 586b0f63ef31fde987e00a305e91ee4e2136332e (diff) | |
| download | genenetwork4-6daec6b5d03a80af3e2496b6bf666340b3d718fd.tar.gz | |
log: name the person and the credential, and resolve handles from the registry
The access log said who (`user`) but not with what: with short tokens a
request can be made by a shared credential, so "which person" and "which
credential" are now separate fields -- `scheme` ("jwt" | "opaque") and,
for an opaque token, `token` (its registry handle, e.g.
`agent-ravanan-3`). Never the token or its hash, and the path still
carries no query string.
The line also gains `ts` (RFC 3339 UTC), so a redirected stderr file is
self-describing rather than relying on journald's prefix. Hand-rolled
civil-from-days rather than a new crate: one format, and no Cargo.lock
drift.
scripts/gn4-log.py reads such a log and shows it as a table with the
handle joined against tokens.sqlite: the subject as the registry has it
now (flagging a handle whose subject has been repointed), and the token's
status today -- [revoked], [expired], [unknown] -- which is how "an agent
was working at 14:02" is told apart from "an agent was working at 14:02
with a credential revoked since". It reads the registry read-only, passes
non-JSON lines through in table mode (the process log interleaves
backtraces), and offers --json and --summary for jq and for counting.
CallerSlot now carries the whole Caller (scheme, id, subject) rather than
just the subject string.
Diffstat (limited to 'src')
| -rw-r--r-- | src/auth.rs | 34 | ||||
| -rw-r--r-- | src/lib.rs | 101 |
2 files changed, 121 insertions, 14 deletions
diff --git a/src/auth.rs b/src/auth.rs index a2036e1..23ef582 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -62,18 +62,36 @@ pub const USER_HEADER: &str = "x-gn4-user"; /// [`crate::lib::tag_caller`] to put on the response, since the extractor /// runs inside the handler and the middleware outside it. #[derive(Debug, Clone, Default)] -pub struct CallerSlot(std::sync::Arc<std::sync::Mutex<Option<String>>>); +pub struct CallerSlot(std::sync::Arc<std::sync::Mutex<Option<Caller>>>); + +/// Who a request ran as, and with which credential. The subject is a +/// gn-auth user id; `id` is the registry handle of an opaque token +/// (`agent-ravanan-3`) and `None` for a JWT. Both go to the access log, +/// because "which person, with which credential" is two different +/// questions -- a shared token and a personal one can carry the same +/// subject, and a token's handle is what `scripts/gn4-log.py` resolves +/// against the registry. +#[derive(Debug, Clone)] +pub struct Caller { + pub scheme: Scheme, + pub id: Option<String>, + pub subject: String, +} impl CallerSlot { - /// Record the subject of the verified token. - pub fn set(&self, subject: &str) { + /// Record the identity of the verified credential. + pub fn set(&self, scheme: Scheme, id: Option<&str>, subject: &str) { if let Ok(mut slot) = self.0.lock() { - *slot = Some(subject.to_string()); + *slot = Some(Caller { + scheme, + id: id.map(str::to_string), + subject: subject.to_string(), + }); } } - /// The subject, if a handler got as far as verifying a token. - pub fn get(&self) -> Option<String> { + /// The caller, if a handler got as far as verifying a token. + pub fn get(&self) -> Option<Caller> { self.0.lock().ok().and_then(|slot| slot.clone()) } } @@ -161,7 +179,7 @@ impl<S: Send + Sync> FromRequestParts<S> for AuthToken { .map_err(|e| unauthorized(&format!("token registry error: {e}")))? .ok_or_else(|| unauthorized("That token is not valid, has been revoked or has expired."))?; if let Some(slot) = parts.extensions.get::<CallerSlot>() { - slot.set(&record.subject); + slot.set(Scheme::Opaque, Some(&record.id), &record.subject); } return Ok(AuthToken { scheme: Scheme::Opaque, @@ -176,7 +194,7 @@ impl<S: Send + Sync> FromRequestParts<S> for AuthToken { verify(token, &config.auth_server_url).map_err(|e| unauthorized(&e.to_string()))?; // For the response header the proxy logs (see `CallerSlot`). if let Some(slot) = parts.extensions.get::<CallerSlot>() { - slot.set(&claims.sub); + slot.set(Scheme::Jwt, None, &claims.sub); } Ok(AuthToken { scheme: Scheme::Jwt, diff --git a/src/lib.rs b/src/lib.rs index 3222369..273554d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -94,7 +94,8 @@ async fn tag_caller( .and_then(|value| value.to_str().ok()) .map(str::to_string); let mut response = next.run(request).await; - let subject = slot.get(); + let caller = slot.get(); + let subject = caller.as_ref().map(|caller| caller.subject.clone()); if let Some(subject) = &subject { // The subject is a gn-auth user id (an ASCII username); anything // else is dropped rather than turned into an invalid header. @@ -116,7 +117,7 @@ async fn tag_caller( response.status().as_u16(), started.elapsed().as_millis(), request_id.as_deref(), - subject.as_deref(), + caller.as_ref(), ) ); } @@ -127,13 +128,19 @@ async fn tag_caller( /// the error lines. `user` is absent rather than `"-"` when nobody was /// identified -- an unauthenticated request has no subject, and a dash would be /// a value a reader could mistake for a user name. +/// +/// `scheme` and (for an opaque token) `token` say which credential was +/// used, never the credential itself: `{"scheme":"opaque","token":"agent-1"}` +/// lets `scripts/gn4-log.py` resolve the handle against the registry -- the +/// subject as it is *now*, the token's status and its note -- without the log +/// ever holding a secret or a hash. fn request_log_line( method: &str, path: &str, status: u16, took_ms: u128, request_id: Option<&str>, - user: Option<&str>, + caller: Option<&crate::auth::Caller>, ) -> String { let mut line = serde_json::json!({ "event": "request", @@ -142,15 +149,55 @@ fn request_log_line( "status": status, "took_ms": took_ms, }); + if let Some(object) = line.as_object_mut() { + object.insert("ts".to_string(), serde_json::json!(rfc3339_utc_now())); + } if let (Some(request_id), Some(object)) = (request_id, line.as_object_mut()) { object.insert("request_id".to_string(), serde_json::json!(request_id)); } - if let (Some(user), Some(object)) = (user, line.as_object_mut()) { - object.insert("user".to_string(), serde_json::json!(user)); + if let (Some(caller), Some(object)) = (caller, line.as_object_mut()) { + object.insert("user".to_string(), serde_json::json!(caller.subject)); + object.insert("scheme".to_string(), serde_json::json!(caller.scheme.as_str())); + if let Some(id) = &caller.id { + object.insert("token".to_string(), serde_json::json!(id)); + } } line.to_string() } +/// The current time as RFC 3339 UTC, e.g. `2026-11-14T14:02:11Z`. +/// +/// Hand-rolled rather than pulling in a date crate: the access log needs +/// one format, `time` is only a transitive dependency (see docs/dev/SKILL.md +/// on Cargo.lock drift), and this is the civil-from-days inverse of +/// `auth.rs`'s `days_from_civil`. +fn rfc3339_utc_now() -> String { + let seconds = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|since| since.as_secs() as i64) + .unwrap_or(0); + let days = seconds.div_euclid(86_400); + let of_day = seconds.rem_euclid(86_400); + // Howard Hinnant's civil_from_days. + let z = days + 719_468; + let era = z.div_euclid(146_097); + let day_of_era = z - era * 146_097; + let year_of_era = + (day_of_era - day_of_era / 1_460 + day_of_era / 36_524 - day_of_era / 146_096) / 365; + let year = year_of_era + era * 400; + let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100); + let mp = (5 * day_of_year + 2) / 153; + let day = day_of_year - (153 * mp + 2) / 5 + 1; + let month = if mp < 10 { mp + 3 } else { mp - 9 }; + let year = if month <= 2 { year + 1 } else { year }; + format!( + "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}Z", + of_day / 3600, + (of_day % 3600) / 60, + of_day % 60 + ) +} + /// Build the application router. Public so integration tests (tests/) and /// the binary (src/main.rs) can both use it without binding a real socket. pub fn app() -> Router { @@ -377,10 +424,26 @@ async fn version(ctx: Ctx) -> Json<Envelope<VersionInfo>> { #[cfg(test)] mod access_log_tests { use super::request_log_line; + use crate::auth::{Caller, Scheme}; + + fn caller(scheme: Scheme, id: Option<&str>, subject: &str) -> Caller { + Caller { + scheme, + id: id.map(str::to_string), + subject: subject.to_string(), + } + } #[test] fn the_line_names_the_user_and_never_the_query() { - let line = request_log_line("GET", "/groups/BXD", 200, 17, Some("abc"), Some("zachs")); + let line = request_log_line( + "GET", + "/groups/BXD", + 200, + 17, + Some("abc"), + Some(&caller(Scheme::Jwt, None, "zachs")), + ); let parsed: serde_json::Value = serde_json::from_str(&line).unwrap(); assert_eq!(parsed["event"], "request"); assert_eq!(parsed["method"], "GET"); @@ -389,6 +452,32 @@ mod access_log_tests { assert_eq!(parsed["took_ms"], 17); assert_eq!(parsed["request_id"], "abc"); assert_eq!(parsed["user"], "zachs"); + assert_eq!(parsed["scheme"], "jwt"); + assert!( + parsed["ts"].as_str().is_some_and(|ts| ts.len() == 20 && ts.ends_with('Z')), + "the line is self-describing: {}", + parsed["ts"] + ); + assert!(parsed.get("token").is_none(), "a JWT has no registry handle"); + } + + /// An opaque token names its registry handle, never the token or its + /// hash: the handle is what a reader resolves against `tokens.sqlite`. + #[test] + fn an_opaque_token_logs_its_handle_and_not_the_secret() { + let line = request_log_line( + "POST", + "/compute/gemma", + 200, + 900, + None, + Some(&caller(Scheme::Opaque, Some("agent-ravanan-3"), "zachs")), + ); + let parsed: serde_json::Value = serde_json::from_str(&line).unwrap(); + assert_eq!(parsed["user"], "zachs"); + assert_eq!(parsed["scheme"], "opaque"); + assert_eq!(parsed["token"], "agent-ravanan-3"); + assert!(!line.contains("gn4ai_"), "{line}"); } /// An unauthenticated request has no subject; a dash would be a value a |
