about summary refs log tree commit diff
path: root/src
diff options
context:
space:
mode:
authorPjotr Prins <pjotr.public01@thebird.nl>2026-11-14 15:10:28 +0000
committerPjotr Prins <pjotr.public01@thebird.nl>2026-11-14 15:10:28 +0000
commit6daec6b5d03a80af3e2496b6bf666340b3d718fd (patch)
tree842d614ba0a5cdd72473ea0d96eb061fd8fef0f5 /src
parent586b0f63ef31fde987e00a305e91ee4e2136332e (diff)
downloadgenenetwork4-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.rs34
-rw-r--r--src/lib.rs101
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