#![cfg(feature = "protocol-qrlogin")]
use std::sync::Arc;
use async_trait::async_trait;
use axum::extract::State;
use axum::http::{HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use axum::{Json, Router};
use chrono::Utc;
use serde::Deserialize;
use serde_json::json;
use crate::error::{GarrisonError, GarrisonResult};
use crate::loc;
use crate::manager::GarrisonManager;
use crate::protocol::qrlogin::{
QrLoginAction, QrLoginPollOutcome, QrLoginService, QrLoginSessionIssuer, QrLoginWebContext,
};
use crate::stp::session::SessionLogic;
use crate::stp::with_current_token;
use crate::stp::LoginParams;
pub struct QrLoginHttpState {
pub service: Arc<QrLoginService>,
pub issuer: Arc<dyn QrLoginSessionIssuer>,
}
pub struct GarrisonQrLoginIssuer;
#[async_trait]
impl QrLoginSessionIssuer for GarrisonQrLoginIssuer {
async fn resolve_app_login_id(&self, app_token: &str) -> GarrisonResult<String> {
let logic = GarrisonManager::logic()?;
let login_id =
with_current_token(app_token.to_string(), async { logic.get_login_id().await }).await?;
login_id.ok_or_else(|| {
GarrisonError::InvalidToken(loc!(
"qrlogin-app-unauthorized",
"QR login requires a valid app session token".to_string()
))
})
}
async fn issue_session(&self, login_id: &str) -> GarrisonResult<String> {
let logic = GarrisonManager::logic()?;
let params = LoginParams {
device: Some("qrlogin".to_string()),
..Default::default()
};
logic.login(login_id, ¶ms).await
}
}
pub fn qrlogin_external_router(state: Arc<QrLoginHttpState>) -> Router {
Router::new()
.route("/qrlogin/create", post(create_endpoint))
.route("/qrlogin/poll", post(poll_endpoint))
.route("/qrlogin/scan", post(scan_endpoint))
.route("/qrlogin/confirm", post(confirm_endpoint))
.with_state(state)
}
#[derive(Deserialize)]
pub struct QrLoginPollRequest {
pub qr_id: String,
pub bind_token: String,
}
#[derive(Deserialize)]
pub struct QrLoginScanRequest {
pub qr_content: String,
}
#[derive(Deserialize)]
pub struct QrLoginConfirmRequest {
pub confirm_token: String,
pub action: String,
}
async fn create_endpoint(
State(state): State<Arc<QrLoginHttpState>>,
ip_ext: Option<axum::Extension<crate::server::middleware::ClientIp>>,
headers: HeaderMap,
) -> Response {
let ip = ip_ext
.map(|axum::Extension(c)| c.0)
.filter(|s| !s.is_empty() && s != "unknown");
let user_agent = headers
.get(axum::http::header::USER_AGENT)
.and_then(|v| v.to_str().ok())
.map(|s| s.to_string());
let web = QrLoginWebContext {
ip,
user_agent,
created_at_ms: Utc::now().timestamp_millis(),
};
match state.service.create_session(web).await {
Ok(created) => (
StatusCode::OK,
Json(json!({
"qr_id": created.qr_id,
"bind_token": created.bind_token,
"qr_content": created.qr_content,
"expires_in_secs": created.expires_in_secs,
})),
)
.into_response(),
Err(e) => error_response(e),
}
}
async fn poll_endpoint(
State(state): State<Arc<QrLoginHttpState>>,
Json(req): Json<QrLoginPollRequest>,
) -> Response {
match state.service.poll(&req.qr_id, &req.bind_token).await {
Ok(outcome) => match outcome {
QrLoginPollOutcome::Pending => ok_json(json!({ "status": "pending" })),
QrLoginPollOutcome::Scanned => ok_json(json!({ "status": "scanned" })),
QrLoginPollOutcome::Cancelled => ok_json(json!({ "status": "cancelled" })),
QrLoginPollOutcome::Expired => ok_json(json!({ "status": "expired" })),
QrLoginPollOutcome::Confirmed { login_id, .. } => {
match state.issuer.issue_session(&login_id).await {
Ok(token) => ok_json(json!({ "status": "confirmed", "token": token })),
Err(e) => error_response(GarrisonError::Internal(loc!(
"qrlogin-issuer-failed",
format!("QR login session issuance failed: {}", e),
("detail", &format!("{}", e))
))),
}
},
},
Err(e) => error_response(e),
}
}
fn app_context(
ip_ext: Option<axum::Extension<crate::server::middleware::ClientIp>>,
headers: &HeaderMap,
) -> Option<(String, String)> {
let ip = ip_ext
.map(|axum::Extension(c)| c.0)
.filter(|s| !s.is_empty() && s != "unknown")?;
let user_agent = headers
.get(axum::http::header::USER_AGENT)
.and_then(|v| v.to_str().ok())
.map(|s| s.to_string())?;
Some((ip, user_agent))
}
async fn scan_endpoint(
State(state): State<Arc<QrLoginHttpState>>,
ip_ext: Option<axum::Extension<crate::server::middleware::ClientIp>>,
headers: HeaderMap,
Json(req): Json<QrLoginScanRequest>,
) -> Response {
let app_token = match bearer_token(&headers) {
Some(token) => token,
None => return unauthorized(),
};
let app_login_id = match state.issuer.resolve_app_login_id(&app_token).await {
Ok(id) => id,
Err(_) => return unauthorized(),
};
match state
.service
.scan(
&req.qr_content,
&app_login_id,
app_context(ip_ext, &headers),
)
.await
{
Ok(view) => ok_json(json!({
"confirm_token": view.confirm_token,
"web_device_label": view.web_device_label,
"web_created_at_ms": view.web_created_at_ms,
"expires_in_secs": view.expires_in_secs,
})),
Err(e) => error_response(e),
}
}
async fn confirm_endpoint(
State(state): State<Arc<QrLoginHttpState>>,
ip_ext: Option<axum::Extension<crate::server::middleware::ClientIp>>,
headers: HeaderMap,
Json(req): Json<QrLoginConfirmRequest>,
) -> Response {
let app_token = match bearer_token(&headers) {
Some(token) => token,
None => return unauthorized(),
};
let app_login_id = match state.issuer.resolve_app_login_id(&app_token).await {
Ok(id) => id,
Err(_) => return unauthorized(),
};
let action = match req.action.as_str() {
"confirm" => QrLoginAction::Confirm,
"cancel" => QrLoginAction::Cancel,
_ => {
return (
StatusCode::BAD_REQUEST,
Json(json!({ "error": loc!(
"qrlogin-action-invalid",
"action must be \"confirm\" or \"cancel\"".to_string()
) })),
)
.into_response()
},
};
match state
.service
.confirm(
&req.confirm_token,
&app_login_id,
action,
app_context(ip_ext, &headers),
)
.await
{
Ok(status) => {
let status_str = if status == crate::protocol::qrlogin::QrLoginStatus::Confirmed {
"confirmed"
} else {
"cancelled"
};
ok_json(json!({ "status": status_str }))
},
Err(e) => error_response(e),
}
}
fn ok_json(value: serde_json::Value) -> Response {
(StatusCode::OK, Json(value)).into_response()
}
fn unauthorized() -> Response {
(
StatusCode::UNAUTHORIZED,
Json(json!({ "error": loc!(
"qrlogin-app-unauthorized",
"QR login requires a valid app session token".to_string()
) })),
)
.into_response()
}
fn error_response(e: GarrisonError) -> Response {
let status = match &e {
GarrisonError::InvalidParam(_) | GarrisonError::InvalidToken(_) => StatusCode::BAD_REQUEST,
_ => StatusCode::INTERNAL_SERVER_ERROR,
};
(status, Json(json!({ "error": format!("{}", e) }))).into_response()
}
fn bearer_token(headers: &HeaderMap) -> Option<String> {
let value = headers
.get(axum::http::header::AUTHORIZATION)?
.to_str()
.ok()?;
let token = value
.strip_prefix("Bearer ")
.or_else(|| value.strip_prefix("bearer "))?;
let token = token.trim();
if token.is_empty() {
None
} else {
Some(token.to_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::{GarrisonDao, InMemoryDao};
use axum::body::Body;
use axum::http::Request;
use http_body_util::BodyExt;
use tower::ServiceExt;
struct MockIssuer;
#[async_trait]
impl QrLoginSessionIssuer for MockIssuer {
async fn resolve_app_login_id(&self, app_token: &str) -> GarrisonResult<String> {
match app_token {
"valid-app-token" => Ok("user-1".to_string()),
"valid-app-token-2" => Ok("user-2".to_string()),
_ => Err(GarrisonError::InvalidToken(
"mock-invalid-token".to_string(),
)),
}
}
async fn issue_session(&self, _login_id: &str) -> GarrisonResult<String> {
Ok("issued-session-token".to_string())
}
}
fn make_app() -> Router {
let dao: Arc<dyn GarrisonDao> = Arc::new(InMemoryDao::new());
let service = Arc::new(
QrLoginService::new(dao, "test-secret-key-0123456789abcdef-0123456789abcdef").unwrap(),
);
let state = Arc::new(QrLoginHttpState {
service,
issuer: Arc::new(MockIssuer),
});
qrlogin_external_router(state)
}
async fn post_json(
app: Router,
path: &str,
body: serde_json::Value,
bearer: Option<&str>,
) -> (StatusCode, serde_json::Value) {
let mut builder = Request::builder()
.method("POST")
.uri(path)
.header("content-type", "application/json");
if let Some(token) = bearer {
builder = builder.header("authorization", format!("Bearer {token}"));
}
let response = app
.oneshot(
builder
.body(Body::from(body.to_string()))
.expect("request build should succeed"),
)
.await
.expect("oneshot should succeed");
let status = response.status();
let bytes = response.into_body().collect().await.unwrap().to_bytes();
let json = if bytes.is_empty() {
serde_json::Value::Null
} else {
serde_json::from_slice(&bytes).unwrap_or(serde_json::Value::Null)
};
(status, json)
}
async fn create_session(app: Router) -> (String, String, String) {
let (status, json) = post_json(app, "/qrlogin/create", json!({}), None).await;
assert_eq!(status, StatusCode::OK);
(
json["qr_id"].as_str().unwrap().to_string(),
json["bind_token"].as_str().unwrap().to_string(),
json["qr_content"].as_str().unwrap().to_string(),
)
}
#[tokio::test]
async fn create_returns_qr_id_and_content() {
let app = make_app();
let (status, json) = post_json(app, "/qrlogin/create", json!({}), None).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(json["qr_id"].as_str().unwrap().len(), 64);
assert!(json["qr_content"].as_str().unwrap().contains("t="));
assert_eq!(json["expires_in_secs"].as_u64(), Some(120));
}
#[tokio::test]
async fn poll_pending_after_create() {
let app = make_app();
let (qr_id, bind_token, _) = create_session(app.clone()).await;
let (status, json) = post_json(
app,
"/qrlogin/poll",
json!({ "qr_id": qr_id, "bind_token": bind_token }),
None,
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(json["status"], "pending");
}
#[tokio::test]
async fn scan_without_bearer_is_401() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let app = make_app();
let (_, _bind_token, qr_content) = create_session(app.clone()).await;
let (status, json) = post_json(
app,
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
None,
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert!(
json["error"]
.as_str()
.unwrap()
.contains("app session token"),
"错误应含 app session token 语义,实际: {}",
json["error"]
);
}
#[tokio::test]
async fn scan_with_bearer_returns_confirm_token() {
let app = make_app();
let (_, _bind_token, qr_content) = create_session(app.clone()).await;
let (status, json) = post_json(
app,
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::OK);
assert!(!json["confirm_token"].as_str().unwrap().is_empty());
assert_eq!(json["web_device_label"], "Unknown device");
assert_eq!(json["expires_in_secs"], 60);
}
#[tokio::test]
async fn full_flow_confirm_and_exchange() {
let app = make_app();
let (qr_id, bind_token, qr_content) = create_session(app.clone()).await;
let (status, scan_json) = post_json(
app.clone(),
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::OK);
let confirm_token = scan_json["confirm_token"].as_str().unwrap().to_string();
let (_, poll_json) = post_json(
app.clone(),
"/qrlogin/poll",
json!({ "qr_id": qr_id, "bind_token": bind_token }),
None,
)
.await;
assert_eq!(poll_json["status"], "scanned");
let (status, confirm_json) = post_json(
app.clone(),
"/qrlogin/confirm",
json!({ "confirm_token": confirm_token, "action": "confirm" }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(confirm_json["status"], "confirmed");
let (status, poll_json) = post_json(
app,
"/qrlogin/poll",
json!({ "qr_id": qr_id, "bind_token": bind_token }),
None,
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(poll_json["status"], "confirmed");
assert_eq!(poll_json["token"], "issued-session-token");
}
#[tokio::test]
async fn confirm_cancel_flow() {
let app = make_app();
let (qr_id, bind_token, qr_content) = create_session(app.clone()).await;
let (_, scan_json) = post_json(
app.clone(),
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
Some("valid-app-token"),
)
.await;
let confirm_token = scan_json["confirm_token"].as_str().unwrap().to_string();
let (status, confirm_json) = post_json(
app.clone(),
"/qrlogin/confirm",
json!({ "confirm_token": confirm_token, "action": "cancel" }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(confirm_json["status"], "cancelled");
let (_, poll_json) = post_json(
app,
"/qrlogin/poll",
json!({ "qr_id": qr_id, "bind_token": bind_token }),
None,
)
.await;
assert_eq!(poll_json["status"], "cancelled");
}
#[tokio::test]
async fn scan_forged_ticket_is_400() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let app = make_app();
let (status, json) = post_json(
app,
"/qrlogin/scan",
json!({ "qr_content": "garrison://qrlogin?t=forged.bad_sig" }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert!(json["error"].as_str().unwrap().contains("signature"));
}
#[tokio::test]
async fn confirm_invalid_action_is_400() {
let app = make_app();
let (_, _bind_token, qr_content) = create_session(app.clone()).await;
let (_, scan_json) = post_json(
app.clone(),
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
Some("valid-app-token"),
)
.await;
let confirm_token = scan_json["confirm_token"].as_str().unwrap().to_string();
let (status, _) = post_json(
app,
"/qrlogin/confirm",
json!({ "confirm_token": confirm_token, "action": "hack" }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn confirm_invalid_action_message_is_localized() {
let app = make_app();
let _guard = crate::i18n::set_locale(crate::i18n::GarrisonLocale::Zh);
let (status, json) = post_json(
app,
"/qrlogin/confirm",
json!({ "confirm_token": "whatever", "action": "hack" }),
Some("valid-app-token"),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert!(
json["error"].as_str().unwrap().contains("必须为"),
"zh locale 应返回 Fluent 翻译,实际: {}",
json["error"]
);
}
#[tokio::test]
async fn confirm_by_other_user_is_400() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let app = make_app();
let (_, _bind_token, qr_content) = create_session(app.clone()).await;
let (_, scan_json) = post_json(
app.clone(),
"/qrlogin/scan",
json!({ "qr_content": qr_content }),
Some("valid-app-token"),
)
.await;
let confirm_token = scan_json["confirm_token"].as_str().unwrap().to_string();
let (status, json) = post_json(
app,
"/qrlogin/confirm",
json!({ "confirm_token": confirm_token, "action": "confirm" }),
Some("valid-app-token-2"),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert!(
json["error"].as_str().unwrap().contains("confirm token"),
"错误应与 token 无效同族(无区分度),实际: {}",
json["error"]
);
}
}