Skip to content

World's first open-source enterprise world model.

Reject invalid personal access token expiration before issuance (#1084)

Daniel08731a3e6843
diff --git a/crates/utopia-server/src/api/token_routes.rs b/crates/utopia-server/src/api/token_routes.rs
index c56283e3..c287d91e 100644
--- a/crates/utopia-server/src/api/token_routes.rs
+++ b/crates/utopia-server/src/api/token_routes.rs
@@ -5,8 +5,10 @@
use axum::extract::{Path, State};
use axum::Json;
+use chrono::{DateTime, Duration, Utc};
use serde::Deserialize;
use serde_json::json;
+use utopia_core::{AppError, AppResult};
use uuid::Uuid;
use crate::auth::AuthUser;
@@ -35,14 +37,36 @@ fn default_days() -> i64 {
90
}
+fn token_expires_at(now: DateTime<Utc>, expires_in_days: i64) -> AppResult<Option<DateTime<Utc>>> {
+ if expires_in_days < 0 {
+ return Err(AppError::invalid(
+ "bad_token_expiry",
+ "expires_in_days must be non-negative",
+ ));
+ }
+ if expires_in_days == 0 {
+ return Ok(None);
+ }
+
+ let duration = Duration::try_days(expires_in_days).ok_or_else(|| {
+ AppError::invalid(
+ "bad_token_expiry",
+ "Token expiration duration is out of range",
+ )
+ })?;
+ let expires_at = now.checked_add_signed(duration).ok_or_else(|| {
+ AppError::invalid("bad_token_expiry", "Token expiration date is out of range")
+ })?;
+ Ok(Some(expires_at))
+}
+
/// 发一枚。**明文只在这一次的响应里出现**,之后库里只有哈希。
pub async fn issue(
State(state): State<AppState>,
AuthUser(user): AuthUser,
Json(req): Json<IssueReq>,
) -> ApiResult<Json<serde_json::Value>> {
- let expires_at = (req.expires_in_days > 0)
- .then(|| chrono::Utc::now() + chrono::Duration::days(req.expires_in_days));
+ let expires_at = token_expires_at(Utc::now(), req.expires_in_days)?;
let (view, plain) = utopia_store::tokens::issue(
&state.pool,
user.id,
@@ -92,3 +116,7 @@ pub async fn revoke(
.await;
Ok(Json(json!({ "ok": true })))
}
+
+#[cfg(test)]
+#[path = "token_routes_tests.rs"]
+mod tests;
diff --git a/crates/utopia-server/src/api/token_routes_tests.rs b/crates/utopia-server/src/api/token_routes_tests.rs
new file mode 100644
index 00000000..5eec3c06
--- /dev/null
+++ b/crates/utopia-server/src/api/token_routes_tests.rs
@@ -0,0 +1,197 @@
+use super::{token_expires_at, IssueReq};
+use axum::body::{to_bytes, Body};
+use axum::http::{Request, StatusCode};
+use chrono::{DateTime, Duration, TimeZone, Utc};
+use serde_json::{json, Value};
+use std::sync::Arc;
+use tower::ServiceExt;
+use utopia_core::AppError;
+use uuid::Uuid;
+
+#[test]
+fn omitted_expiration_defaults_to_ninety_days() {
+ let request: IssueReq = serde_json::from_value(json!({ "name": "laptop" })).unwrap();
+ let now = Utc.with_ymd_and_hms(2026, 1, 1, 12, 0, 0).unwrap();
+
+ assert_eq!(request.expires_in_days, 90);
+ assert_eq!(
+ token_expires_at(now, request.expires_in_days).unwrap(),
+ Some(Utc.with_ymd_and_hms(2026, 4, 1, 12, 0, 0).unwrap())
+ );
+}
+
+#[test]
+fn zero_is_permanent_and_representable_positive_days_are_accepted() {
+ let now = Utc.with_ymd_and_hms(2026, 1, 1, 12, 0, 0).unwrap();
+ assert_eq!(token_expires_at(now, 0).unwrap(), None);
+
+ for days in [1, 365, 1_000_000] {
+ let expires_at = token_expires_at(now, days).unwrap().unwrap();
+ assert_eq!(expires_at.signed_duration_since(now), Duration::days(days));
+ }
+
+ // 上限来自日期能否表示,不是任意的业务天数限制。
+ let last_valid_days = DateTime::<Utc>::MAX_UTC
+ .signed_duration_since(now)
+ .num_days();
+ assert!(token_expires_at(now, last_valid_days).unwrap().is_some());
+ assert!(token_expires_at(now, last_valid_days + 1).is_err());
+}
+
+#[test]
+fn negative_days_and_both_overflow_paths_are_validation_errors() {
+ let now = Utc.with_ymd_and_hms(2026, 1, 1, 12, 0, 0).unwrap();
+ let date_overflow = Duration::try_days(100_000_000).unwrap();
+ assert!(now.checked_add_signed(date_overflow).is_none());
+ assert!(Duration::try_days(i64::MAX).is_none());
+
+ for (days, expected_message) in [
+ (-1, "expires_in_days must be non-negative"),
+ (i64::MIN, "expires_in_days must be non-negative"),
+ (100_000_000, "Token expiration date is out of range"),
+ (i64::MAX, "Token expiration duration is out of range"),
+ ] {
+ let error = token_expires_at(now, days).unwrap_err();
+ match error {
+ AppError::Invalid {
+ code,
+ message,
+ detail,
+ } => {
+ assert_eq!(code, "bad_token_expiry", "days={days}");
+ assert_eq!(message, expected_message, "days={days}");
+ assert!(detail.is_none());
+ }
+ other => panic!("expected validation error for days={days}, got {other:?}"),
+ }
+ }
+}
+
+#[tokio::test]
+async fn issue_route_validates_expiration_before_writing_tokens_or_success_audits(
+) -> anyhow::Result<()> {
+ let Some(url) = utopia_store::test_db::url() else {
+ return Ok(());
+ };
+ let pool = sqlx::PgPool::connect(&url).await?;
+ utopia_store::db::migrate(&pool).await?;
+ let org_id = Uuid::now_v7();
+ let user_id = Uuid::now_v7();
+ let directory = tempfile::tempdir()?;
+ let config = utopia_core::config::AppConfig {
+ data_dir: directory.path().to_string_lossy().into_owned(),
+ ..Default::default()
+ };
+ let search = Arc::new(utopia_search::SearchIndex::open(
+ &directory.path().join("search"),
+ )?);
+ let state = crate::state::AppState::new(pool.clone(), &config, search, "test-only".into());
+ let session_token = crate::auth::issue_token(&state, user_id)?;
+ let app = crate::api::router(state, &config);
+
+ let result = async {
+ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'token-expiry-test')")
+ .bind(org_id)
+ .execute(&pool)
+ .await?;
+ sqlx::query(
+ "INSERT INTO users (id, org_id, email, password_hash, display_name)
+ VALUES ($1, $2, $3, 'unused', 'Token Expiry Test')",
+ )
+ .bind(user_id)
+ .bind(org_id)
+ .bind(format!("{user_id}@token-expiry.test"))
+ .execute(&pool)
+ .await?;
+
+ let mut issued_count = 0_i64;
+ for (requested_days, accepted_days) in [
+ (None, Some(90)),
+ (Some(0), Some(0)),
+ (Some(1), Some(1)),
+ (Some(365), Some(365)),
+ (Some(-1), None),
+ (Some(i64::MIN), None),
+ (Some(100_000_000), None),
+ (Some(i64::MAX), None),
+ ] {
+ let mut payload = json!({ "name": "laptop" });
+ if let Some(days) = requested_days {
+ payload["expires_in_days"] = json!(days);
+ }
+ let request = Request::builder()
+ .method("POST")
+ .uri("/api/v1/me/tokens")
+ .header("authorization", format!("Bearer {session_token}"))
+ .header("content-type", "application/json")
+ .body(Body::from(payload.to_string()))?;
+ let before = Utc::now();
+ let response = app.clone().oneshot(request).await?;
+ let after = Utc::now();
+ let status = response.status();
+ let bytes = to_bytes(response.into_body(), 65536).await?;
+ let body: Value = serde_json::from_slice(&bytes)?;
+
+ if let Some(days) = accepted_days {
+ anyhow::ensure!(status == StatusCode::OK, "{payload}: {status} {body}");
+ anyhow::ensure!(body["token"]
+ .as_str()
+ .is_some_and(|token| token.starts_with("utp_pat_")));
+ anyhow::ensure!(body["info"]["scope"] == "read");
+ anyhow::ensure!(body["info"]["kb_ids"].is_null());
+ let expires_at: Option<DateTime<Utc>> =
+ serde_json::from_value(body["info"]["expires_at"].clone())?;
+ if days == 0 {
+ anyhow::ensure!(expires_at.is_none());
+ } else {
+ let expires_at =
+ expires_at.ok_or_else(|| anyhow::anyhow!("missing expiration"))?;
+ // PostgreSQL 保留微秒,比较时使用同一精度。
+ let earliest = (before + Duration::days(days)).timestamp_micros();
+ let latest = (after + Duration::days(days)).timestamp_micros();
+ anyhow::ensure!((earliest..=latest).contains(&expires_at.timestamp_micros()));
+ }
+ issued_count += 1;
+ } else {
+ anyhow::ensure!(
+ status == StatusCode::UNPROCESSABLE_ENTITY,
+ "{payload}: {status} {body}"
+ );
+ anyhow::ensure!(body["code"] == "bad_token_expiry");
+ anyhow::ensure!(body["error"]
+ .as_str()
+ .is_some_and(|message| !message.is_empty()));
+ anyhow::ensure!(body.get("token").is_none());
+ }
+
+ let token_count: i64 =
+ sqlx::query_scalar("SELECT count(*) FROM personal_tokens WHERE user_id = $1")
+ .bind(user_id)
+ .fetch_one(&pool)
+ .await?;
+ let audit_count: i64 = sqlx::query_scalar(
+ "SELECT count(*) FROM audit_events WHERE actor_id = $1 AND action = 'token.issued'",
+ )
+ .bind(user_id)
+ .fetch_one(&pool)
+ .await?;
+ anyhow::ensure!(
+ token_count == issued_count,
+ "unexpected token count for {payload}"
+ );
+ anyhow::ensure!(
+ audit_count == issued_count,
+ "unexpected success audit count for {payload}"
+ );
+ }
+ anyhow::Ok(())
+ }
+ .await;
+
+ // 审计只追加,保留在专用测试库中;随机用户 ID 隔离每次运行的计数。
+ sqlx::query("DELETE FROM organizations WHERE id = $1")
+ .bind(org_id)
+ .execute(&pool)
+ .await?;
+ result
+}