use crate::action::{ActionContext, ApiResponse, TypedHandler, User};
use crate::error::BaseError;
use crate::router::middleware::{Middleware, Next};
use crate::token::TokenClaims;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use yang_base_derive::Action;
#[derive(Clone, Deserialize, schemars::JsonSchema)]
pub struct LoginInput {
pub username: String,
pub password: String,
#[serde(default)]
pub extra: serde_json::Value,
}
impl core::fmt::Debug for LoginInput {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("LoginInput")
.field("username", &self.username)
.field("password", &"***")
.field("extra", &self.extra)
.finish()
}
}
#[derive(Clone, Serialize, schemars::JsonSchema)]
pub struct TokenPairResponse {
pub access_token: String,
pub refresh_token: String,
}
impl core::fmt::Debug for TokenPairResponse {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TokenPairResponse")
.field(
"access_token",
&format!("***({} chars)", self.access_token.len()),
)
.field(
"refresh_token",
&format!("***({} chars)", self.refresh_token.len()),
)
.finish()
}
}
#[derive(Clone, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct RefreshInput {
pub refresh_token: String,
}
impl core::fmt::Debug for RefreshInput {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("RefreshInput")
.field(
"refresh_token",
&format!("***({} chars)", self.refresh_token.len()),
)
.finish()
}
}
#[derive(Clone, Serialize, schemars::JsonSchema)]
pub struct AccessTokenResponse {
pub access_token: String,
}
impl core::fmt::Debug for AccessTokenResponse {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("AccessTokenResponse")
.field(
"access_token",
&format!("***({} chars)", self.access_token.len()),
)
.finish()
}
}
#[derive(Clone, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct LogoutInput {
pub token: String,
#[serde(default)]
pub refresh_token: Option<String>,
}
impl core::fmt::Debug for LogoutInput {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("LogoutInput")
.field("token", &format!("***({} chars)", self.token.len()))
.field(
"refresh_token",
&self
.refresh_token
.as_ref()
.map(|s| format!("***({} chars)", s.len())),
)
.finish()
}
}
#[derive(Debug, Clone, Serialize, schemars::JsonSchema)]
pub struct MessageResponse {
pub message: String,
}
#[derive(Debug, Clone)]
pub struct VerifiedSubject {
pub subject: String,
pub custom_claims: serde_json::Value,
}
impl VerifiedSubject {
pub fn new(subject: impl Into<String>) -> Self {
Self {
subject: subject.into(),
custom_claims: serde_json::Value::Null,
}
}
pub fn with_claims(mut self, claims: serde_json::Value) -> Self {
self.custom_claims = claims;
self
}
}
#[async_trait]
pub trait CredentialVerifier: Send + Sync + 'static {
async fn verify(
&self,
ctx: &ActionContext,
input: &LoginInput,
) -> Result<VerifiedSubject, BaseError>;
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct AuthAuditEvent {
pub request_id: String,
pub action: &'static str,
pub subject: Option<String>,
pub error_code: Option<&'static str>,
}
pub fn token_fingerprint(token: &str) -> String {
let mut hash: u64 = 0xcbf29ce484222325;
for b in token.as_bytes() {
hash ^= *b as u64;
hash = hash.wrapping_mul(0x100000001b3);
}
format!("{:016x}", hash)
}
#[async_trait]
pub trait AuthAuditHook: Send + Sync + 'static {
async fn on_success(&self, event: AuthAuditEvent);
async fn on_failure(&self, event: AuthAuditEvent);
}
#[derive(Debug, Clone, Default)]
pub struct TracingAuditHook;
#[async_trait]
impl AuthAuditHook for TracingAuditHook {
async fn on_success(&self, event: AuthAuditEvent) {
tracing::info!(
request_id = %event.request_id,
action = event.action,
subject = event.subject.as_deref().unwrap_or("-"),
"认证成功",
);
}
async fn on_failure(&self, event: AuthAuditEvent) {
tracing::warn!(
request_id = %event.request_id,
action = event.action,
subject = event.subject.as_deref().unwrap_or("-"),
error_code = event.error_code.unwrap_or("-"),
"认证失败",
);
}
}
#[derive(Action)]
#[action(
name = "login",
display_name = "登录",
description = "校验凭证并签发 Token 对",
public
)]
pub struct LoginAction<V: CredentialVerifier, A: AuthAuditHook = TracingAuditHook> {
verifier: V,
audit: A,
}
impl<V: CredentialVerifier> LoginAction<V, TracingAuditHook> {
pub fn new(verifier: V) -> Self {
Self {
verifier,
audit: TracingAuditHook,
}
}
}
impl<V: CredentialVerifier, A: AuthAuditHook> LoginAction<V, A> {
pub fn with_audit(verifier: V, audit: A) -> Self {
Self { verifier, audit }
}
}
#[async_trait]
impl<V: CredentialVerifier, A: AuthAuditHook> TypedHandler for LoginAction<V, A> {
type Input = LoginInput;
type Output = TokenPairResponse;
async fn handle(
&self,
ctx: ActionContext,
input: LoginInput,
) -> Result<TokenPairResponse, BaseError> {
let request_id = ctx.request_id.to_string();
let subject = match self.verifier.verify(&ctx, &input).await {
Ok(s) => s,
Err(e) => {
self.audit
.on_failure(AuthAuditEvent {
request_id,
action: "login",
subject: Some(input.username.clone()),
error_code: Some(e.code_str()),
})
.await;
return Err(e);
}
};
let result = ctx
.tools
.token_manager()
.generate_token_pair(&subject.subject, subject.custom_claims);
match result {
Ok((access_token, refresh_token)) => {
self.audit
.on_success(AuthAuditEvent {
request_id,
action: "login",
subject: Some(subject.subject.clone()),
error_code: None,
})
.await;
Ok(TokenPairResponse {
access_token,
refresh_token,
})
}
Err(e) => {
self.audit
.on_failure(AuthAuditEvent {
request_id,
action: "login",
subject: Some(subject.subject.clone()),
error_code: Some(e.code_str()),
})
.await;
Err(e)
}
}
}
}
#[async_trait]
pub trait RefreshClaimsResolver: Send + Sync + 'static {
async fn resolve(&self, ctx: &ActionContext, sub: &str)
-> Result<serde_json::Value, BaseError>;
}
#[derive(Debug, Clone, Default)]
pub struct DefaultRefreshClaims;
#[async_trait]
impl RefreshClaimsResolver for DefaultRefreshClaims {
async fn resolve(
&self,
_ctx: &ActionContext,
_sub: &str,
) -> Result<serde_json::Value, BaseError> {
Ok(serde_json::Value::Null)
}
}
#[derive(Action, Default)]
#[action(
name = "refresh",
display_name = "刷新 Token",
description = "用 Refresh Token 换取新的 Access Token",
public
)]
pub struct RefreshAction<
R: RefreshClaimsResolver = DefaultRefreshClaims,
A: AuthAuditHook = TracingAuditHook,
> {
resolver: R,
audit: A,
}
impl<R: RefreshClaimsResolver> RefreshAction<R, TracingAuditHook> {
pub fn new(resolver: R) -> Self {
Self {
resolver,
audit: TracingAuditHook,
}
}
}
impl<R: RefreshClaimsResolver, A: AuthAuditHook> RefreshAction<R, A> {
pub fn with_audit(resolver: R, audit: A) -> Self {
Self { resolver, audit }
}
}
#[async_trait]
impl<R: RefreshClaimsResolver, A: AuthAuditHook> TypedHandler for RefreshAction<R, A> {
type Input = RefreshInput;
type Output = TokenPairResponse;
async fn handle(
&self,
ctx: ActionContext,
input: RefreshInput,
) -> Result<TokenPairResponse, BaseError> {
let request_id = ctx.request_id.to_string();
let manager = ctx.tools.token_manager();
let run = async {
let claims = manager.verify_token_checked(&input.refresh_token).await?;
if claims.token_type != crate::token::TokenType::Refresh {
return Err(BaseError::TokenTypeInvalid(
"期望 refresh token".to_string(),
));
}
let custom_claims = self.resolver.resolve(&ctx, &claims.sub).await?;
let (access_token, refresh_token) = manager
.rotate_refresh_token_from_claims(&claims, custom_claims)
.await?;
Ok::<_, BaseError>((access_token, refresh_token, claims.sub))
};
match run.await {
Ok((access_token, refresh_token, sub)) => {
self.audit
.on_success(AuthAuditEvent {
request_id,
action: "refresh",
subject: Some(sub),
error_code: None,
})
.await;
Ok(TokenPairResponse {
access_token,
refresh_token,
})
}
Err(e) => {
self.audit
.on_failure(AuthAuditEvent {
request_id,
action: "refresh",
subject: None,
error_code: Some(e.code_str()),
})
.await;
Err(e)
}
}
}
}
#[derive(Action, Default)]
#[action(
name = "logout",
display_name = "登出",
description = "撤销 Token,使其在过期前失效",
public
)]
pub struct LogoutAction<A: AuthAuditHook = TracingAuditHook> {
audit: A,
}
impl LogoutAction<TracingAuditHook> {
pub fn new() -> Self {
Self {
audit: TracingAuditHook,
}
}
}
impl<A: AuthAuditHook> LogoutAction<A> {
pub fn with_audit(audit: A) -> Self {
Self { audit }
}
}
#[async_trait]
impl<A: AuthAuditHook> TypedHandler for LogoutAction<A> {
type Input = LogoutInput;
type Output = MessageResponse;
async fn handle(
&self,
ctx: ActionContext,
input: LogoutInput,
) -> Result<MessageResponse, BaseError> {
let request_id = ctx.request_id.to_string();
let manager = ctx.tools.token_manager();
let run = async {
let target_claims = manager.verify_token(&input.token)?;
if let Some(bearer_token) = ctx.request.token() {
let caller_claims = manager.verify_token_checked(bearer_token).await?;
if caller_claims.sub != target_claims.sub {
return Err(BaseError::PermissionDenied(
"只能撤销自己的 Token".to_string(),
));
}
}
manager.revoke_by_subject(&target_claims.sub).await?;
Ok::<(), BaseError>(())
};
match run.await {
Ok(()) => {
self.audit
.on_success(AuthAuditEvent {
request_id,
action: "logout",
subject: Some(token_fingerprint(&input.token)),
error_code: None,
})
.await;
Ok(MessageResponse {
message: "已登出".to_string(),
})
}
Err(e) => {
self.audit
.on_failure(AuthAuditEvent {
request_id,
action: "logout",
subject: Some(token_fingerprint(&input.token)),
error_code: Some(e.code_str()),
})
.await;
Err(e)
}
}
}
}
pub struct TokenAuthMiddleware<F> {
build_user: F,
}
impl<F> TokenAuthMiddleware<F>
where
F: Fn(&TokenClaims) -> User + Send + Sync + 'static,
{
pub fn new(build_user: F) -> Self {
Self { build_user }
}
}
#[async_trait]
impl<F> Middleware for TokenAuthMiddleware<F>
where
F: Fn(&TokenClaims) -> User + Send + Sync + 'static,
{
async fn handle(
&self,
mut ctx: ActionContext,
next: Next<'_>,
) -> Result<ApiResponse, BaseError> {
let token = match ctx.request.token() {
Some(t) => t.to_string(),
None => {
return Err(BaseError::Unauthorized(
"缺少 Authorization Bearer Token".to_string(),
))
}
};
let claims = ctx
.tools
.token_manager()
.verify_token_checked(&token)
.await?;
if claims.token_type != crate::token::TokenType::Access {
return Err(BaseError::TokenTypeInvalid("期望 access token".into()));
}
ctx.user = Some((self.build_user)(&claims));
next.run(ctx).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::action::{DynAction, TypedAction};
struct DummyVerifier;
#[async_trait]
impl CredentialVerifier for DummyVerifier {
async fn verify(
&self,
_ctx: &ActionContext,
input: &LoginInput,
) -> Result<VerifiedSubject, BaseError> {
Ok(VerifiedSubject::new(format!("user:{}", input.username)))
}
}
#[test]
fn test_auth_actions_meta() {
let login = LoginAction::new(DummyVerifier);
assert_eq!(login.name(), "login");
assert!(DynAction::meta(&login).is_public);
let refresh = RefreshAction::<DefaultRefreshClaims>::default();
assert_eq!(refresh.name(), "refresh");
assert!(refresh.is_public());
let logout = LogoutAction::new();
assert_eq!(logout.name(), "logout");
assert!(logout.is_public());
}
#[test]
fn test_token_fingerprint_stable_and_opaque() {
let a = token_fingerprint("super-secret-access-token");
let b = token_fingerprint("super-secret-access-token");
let c = token_fingerprint("another-token");
assert_eq!(a, b, "同一 token 指纹应稳定");
assert_ne!(a, c, "不同 token 指纹应不同");
assert_eq!(a.len(), 16, "指纹为 16 位十六进制");
assert!(!a.contains("secret"), "指纹不得含原文");
}
#[tokio::test]
async fn test_audit_hook_records_without_leaking() {
use std::sync::{Arc, Mutex};
#[derive(Clone, Default)]
struct RecordingHook {
events: Arc<Mutex<Vec<AuthAuditEvent>>>,
}
#[async_trait]
impl AuthAuditHook for RecordingHook {
async fn on_success(&self, event: AuthAuditEvent) {
self.events.lock().unwrap().push(event);
}
async fn on_failure(&self, event: AuthAuditEvent) {
self.events.lock().unwrap().push(event);
}
}
let hook = RecordingHook::default();
let login = LoginAction::with_audit(DummyVerifier, hook.clone());
assert_eq!(login.name(), "login");
hook.on_success(AuthAuditEvent {
request_id: "abc".into(),
action: "login",
subject: Some("user:alice".into()),
error_code: None,
})
.await;
let events = hook.events.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events[0].action, "login");
assert_eq!(events[0].subject.as_deref(), Some("user:alice"));
}
}