use crate::error::{GarrisonError, GarrisonResult};
use crate::oauth2_server::client::OAuth2ClientStore;
use crate::oauth2_server::token::TokenHandler;
use serde::Deserialize;
use std::sync::Arc;
#[derive(Debug, Clone, Deserialize)]
pub struct RevokeRequest {
pub token: String,
pub token_type_hint: Option<String>,
pub client_id: String,
pub client_secret: String,
}
pub struct RevokeHandler {
store: Arc<dyn OAuth2ClientStore>,
token_handler: Arc<TokenHandler>,
}
impl RevokeHandler {
pub fn new(store: Arc<dyn OAuth2ClientStore>, token_handler: Arc<TokenHandler>) -> Self {
Self {
store,
token_handler,
}
}
pub async fn handle(&self, req: &RevokeRequest) -> GarrisonResult<()> {
let client = match self.store.get(&req.client_id).await? {
Some(c) => c,
None => {
return Err(GarrisonError::OAuth2(
"oauth2-server-revoke-invalid-client".into(),
));
},
};
if !client.verify_secret(&req.client_secret)? {
return Err(GarrisonError::OAuth2(
"oauth2-server-revoke-invalid-client".into(),
));
}
if let Err(e) = self.revoke_owned_token(req).await {
tracing::warn!(
error = %e,
"oauth2-server-revoke: revocation failed, returning success per RFC 7009 §2.2"
);
}
Ok(())
}
async fn revoke_owned_token(&self, req: &RevokeRequest) -> GarrisonResult<()> {
let record = match req.token_type_hint.as_deref() {
Some("refresh_token") => {
match self
.token_handler
.get_refresh_token_record(&req.token)
.await?
{
Some(r) => Some(r),
None => {
self.token_handler
.get_access_token_record(&req.token)
.await?
},
}
},
_ => {
match self
.token_handler
.get_access_token_record(&req.token)
.await?
{
Some(r) => Some(r),
None => {
self.token_handler
.get_refresh_token_record(&req.token)
.await?
},
}
},
};
match record {
Some(record) if record.client_id == req.client_id => {
self.token_handler.revoke_token(&req.token).await
},
_ => Ok(()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
use crate::oauth2_server::authorize::AuthorizeHandler;
use crate::oauth2_server::client::{DaoOAuth2ClientStore, GrantType, OAuth2Client};
use crate::oauth2_server::token::{
PasswordRateLimiter, TokenHandler, TokenRateLimiter, TokenRequest,
};
fn make_handlers() -> (RevokeHandler, Arc<InMemoryDao>, Arc<TokenHandler>) {
let dao = Arc::new(InMemoryDao::new());
let store = Arc::new(DaoOAuth2ClientStore::new(dao.clone()));
let authorize_handler = Arc::new(AuthorizeHandler::new(
store.clone(),
dao.clone(),
"https://auth.example.com/login".into(),
));
let token_handler = Arc::new(TokenHandler::new(
store.clone(),
dao.clone(),
authorize_handler,
Arc::new(PasswordRateLimiter::new(1000, 300)),
Arc::new(TokenRateLimiter::with_limits(100_000, 60, 100_000, 60)),
));
let revoke_handler = RevokeHandler::new(store, token_handler.clone());
(revoke_handler, dao, token_handler)
}
fn make_client(id: &str) -> OAuth2Client {
OAuth2Client::new(
id,
"secret-123",
vec!["https://app.example.com/cb".into()],
vec![GrantType::ClientCredentials],
vec!["read".into()],
)
.unwrap()
}
async fn issue_token(token_handler: &TokenHandler, client_id: &str) -> String {
let req = TokenRequest {
grant_type: "client_credentials".into(),
client_id: client_id.into(),
client_secret: "secret-123".into(),
code: None,
redirect_uri: None,
code_verifier: None,
refresh_token: None,
scope: None,
username: None,
password: None,
};
token_handler.handle(&req).await.unwrap().access_token
}
#[tokio::test]
async fn revoke_valid_access_token() {
let (handler, _, token_handler) = make_handlers();
handler.store.create(make_client("rev-001")).await.unwrap();
let token = issue_token(&token_handler, "rev-001").await;
assert!(token_handler
.get_access_token_record(&token)
.await
.unwrap()
.is_some());
let req = RevokeRequest {
token: token.clone(),
token_type_hint: Some("access_token".into()),
client_id: "rev-001".into(),
client_secret: "secret-123".into(),
};
handler.handle(&req).await.expect("撤销");
assert!(token_handler
.get_access_token_record(&token)
.await
.unwrap()
.is_none());
}
#[tokio::test]
async fn revoke_nonexistent_token_returns_ok() {
let (handler, _, _) = make_handlers();
handler.store.create(make_client("rev-002")).await.unwrap();
let req = RevokeRequest {
token: "nonexistent-token".into(),
token_type_hint: None,
client_id: "rev-002".into(),
client_secret: "secret-123".into(),
};
handler.handle(&req).await.expect("应成功");
}
#[tokio::test]
async fn revoke_invalid_client_id() {
let (handler, _, _) = make_handlers();
let req = RevokeRequest {
token: "some-token".into(),
token_type_hint: None,
client_id: "no-such".into(),
client_secret: "secret".into(),
};
let err = handler.handle(&req).await.unwrap_err();
assert!(err
.to_string()
.contains("oauth2-server-revoke-invalid-client"));
}
#[tokio::test]
async fn revoke_invalid_client_secret() {
let (handler, _, _) = make_handlers();
handler.store.create(make_client("rev-003")).await.unwrap();
let req = RevokeRequest {
token: "some-token".into(),
token_type_hint: None,
client_id: "rev-003".into(),
client_secret: "wrong".into(),
};
let err = handler.handle(&req).await.unwrap_err();
assert!(err
.to_string()
.contains("oauth2-server-revoke-invalid-client"));
}
#[tokio::test]
async fn revoke_invalid_client_and_secret_are_indistinguishable() {
let (handler, _, _) = make_handlers();
handler
.store
.create(make_client("rev-enum-001"))
.await
.unwrap();
let bad_id = RevokeRequest {
token: "some-token".into(),
token_type_hint: None,
client_id: "no-such-client".into(),
client_secret: "secret-123".into(),
};
let bad_secret = RevokeRequest {
token: "some-token".into(),
token_type_hint: None,
client_id: "rev-enum-001".into(),
client_secret: "wrong".into(),
};
let err_id = handler.handle(&bad_id).await.unwrap_err().to_string();
let err_secret = handler.handle(&bad_secret).await.unwrap_err().to_string();
assert_eq!(
err_id, err_secret,
"invalid-client 与 invalid-client-secret 必须统一为单一 invalid_client 错误"
);
assert!(!err_id.contains("no-such-client"));
}
#[tokio::test]
async fn revoke_rejects_token_owned_by_other_client() {
let (handler, _, token_handler) = make_handlers();
handler
.store
.create(make_client("rev-owner-001"))
.await
.unwrap();
handler
.store
.create(make_client("rev-attacker-001"))
.await
.unwrap();
let victim_token = issue_token(&token_handler, "rev-owner-001").await;
let req = RevokeRequest {
token: victim_token.clone(),
token_type_hint: Some("access_token".into()),
client_id: "rev-attacker-001".into(),
client_secret: "secret-123".into(),
};
handler.handle(&req).await.expect("应返回成功");
assert!(
token_handler
.get_access_token_record(&victim_token)
.await
.unwrap()
.is_some(),
"归属其他 client 的 token 不得被撤销"
);
let own_req = RevokeRequest {
token: victim_token.clone(),
token_type_hint: Some("access_token".into()),
client_id: "rev-owner-001".into(),
client_secret: "secret-123".into(),
};
handler.handle(&own_req).await.expect("属主撤销应成功");
assert!(token_handler
.get_access_token_record(&victim_token)
.await
.unwrap()
.is_none());
}
}