use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::oauth2_server::client::OAuth2ClientStore;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use percent_encoding::{utf8_percent_encode, AsciiSet};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256, Sha512};
use std::sync::Arc;
const AUTH_CODE_TTL_SECONDS: u64 = 600;
const AUTHORIZE_TICKET_TTL_SECONDS: u64 = 600;
const AUTHORIZE_TICKET_LEN: usize = 32;
const OAUTH2_AUTHORIZE_TICKET_KEY_PREFIX: &str = "oauth2:authorize-ticket:";
const OAUTH2_CONSENT_KEY_PREFIX: &str = "oauth2:consent:";
fn oauth2_refresh_token_key(token: &str) -> String {
debug_assert!(
!token.contains(':'),
"oauth2 refresh_token key: token must not contain ':' (ambiguous key)"
);
format!("oauth2:rtoken:{}", token)
}
fn authorize_ticket_key(ticket: &str) -> String {
debug_assert!(
!ticket.contains(':'),
"authorize ticket key: ticket must not contain ':' (ambiguous key)"
);
format!("{}{}", OAUTH2_AUTHORIZE_TICKET_KEY_PREFIX, ticket)
}
fn consent_key(tenant_id: i64, user_id: i64, client_id: &str) -> String {
debug_assert!(
!client_id.contains(':'),
"consent key: client_id must not contain ':' (ambiguous key)"
);
format!(
"{}{}:{}:{}",
OAUTH2_CONSENT_KEY_PREFIX, tenant_id, user_id, client_id
)
}
fn ticket_invalid_error() -> GarrisonError {
GarrisonError::OAuth2("oauth2-server-authorize-ticket-invalid-or-expired".into())
}
fn current_tenant_id_with_warn() -> i64 {
match crate::context::tenant::current_tenant_id_strict() {
Some(t) => t,
None => {
tracing::warn!(
"{}",
crate::i18n::translate_detail("logs-oauth2-authorize-tenant-context-missing", &[])
);
0
},
}
}
fn interaction_required_error() -> GarrisonError {
GarrisonError::OAuth2("oauth2-server-authorize-interaction-required".into())
}
const CODE_USED_RECORD_TTL_SECONDS: u64 = 2_592_000;
#[derive(Debug, Clone, Serialize, Deserialize)]
struct CodeUsedRecord {
access_token: String,
refresh_token: Option<String>,
}
const CODE_VERIFIER_MIN_LEN: usize = 43;
const CODE_VERIFIER_MAX_LEN: usize = 128;
const S256_CHALLENGE_LEN: usize = 43;
const QUERY_VALUE_ENCODE_SET: &AsciiSet = &percent_encoding::CONTROLS
.add(b' ')
.add(b'!')
.add(b'"')
.add(b'#')
.add(b'$')
.add(b'&')
.add(b'\'')
.add(b'(')
.add(b')')
.add(b'*')
.add(b'+')
.add(b',')
.add(b'/')
.add(b':')
.add(b';')
.add(b'<')
.add(b'=')
.add(b'>')
.add(b'?')
.add(b'@')
.add(b'[')
.add(b'\\')
.add(b']')
.add(b'^')
.add(b'`')
.add(b'{')
.add(b'|')
.add(b'}')
.add(b'%');
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthorizeRequest {
pub response_type: String,
pub client_id: String,
pub redirect_uri: String,
pub scope: Option<String>,
pub state: Option<String>,
pub code_challenge: String,
pub code_challenge_method: String,
#[serde(default)]
pub prompt: Option<String>,
}
impl AuthorizeRequest {
pub fn prompt_hint(&self) -> AuthorizePrompt {
match self.prompt.as_deref().map(str::trim) {
Some("none") => AuthorizePrompt::NoInteraction,
Some("login") => AuthorizePrompt::ForceLogin,
_ => AuthorizePrompt::None,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum AuthorizeResponse {
Redirect {
location: String,
},
LoginRequired {
login_url: String,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthorizationCode {
pub code: String,
pub client_id: String,
pub redirect_uri: String,
pub scopes: Vec<String>,
pub user_id: i64,
pub code_challenge: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConsentDecision {
Remembered,
Required(ConsentRequiredReason),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConsentRequiredReason {
FirstGrant,
ScopeExpansion {
new_scopes: Vec<String>,
},
AttributesChanged,
SnapshotUnreadable,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AttributeSnapshotGranularity {
#[default]
AttributeName,
AttributeValue,
}
pub type ConsentAttributes = (String, Vec<String>);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AuthorizePrompt {
#[default]
None,
NoInteraction,
ForceLogin,
Login,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct ConsentRecord {
granted_scopes: Vec<String>,
attribute_names_hash: String,
attribute_values_hash: String,
}
pub struct AuthorizeHandler {
store: Arc<dyn OAuth2ClientStore>,
dao: Arc<dyn GarrisonDao>,
login_url: String,
consent_url: Option<String>,
attribute_granularity: AttributeSnapshotGranularity,
}
impl AuthorizeHandler {
pub fn new(
store: Arc<dyn OAuth2ClientStore>,
dao: Arc<dyn GarrisonDao>,
login_url: String,
) -> Self {
Self {
store,
dao,
login_url,
consent_url: None,
attribute_granularity: AttributeSnapshotGranularity::default(),
}
}
pub fn with_consent_url(mut self, consent_url: String) -> Self {
self.consent_url = Some(consent_url);
self
}
pub fn with_attribute_granularity(mut self, granularity: AttributeSnapshotGranularity) -> Self {
self.attribute_granularity = granularity;
self
}
pub async fn authorize(
&self,
req: &AuthorizeRequest,
user_id: Option<i64>,
) -> GarrisonResult<AuthorizeResponse> {
self.authorize_with_prompt(req, user_id, AuthorizePrompt::None)
.await
}
pub async fn authorize_with_prompt(
&self,
req: &AuthorizeRequest,
user_id: Option<i64>,
prompt: AuthorizePrompt,
) -> GarrisonResult<AuthorizeResponse> {
validate_request_shape(req)?;
let client = self.load_client(&req.client_id).await?;
if !client.is_redirect_uri_allowed(&req.redirect_uri) {
return Err(GarrisonError::OAuth2(format!(
"oauth2-server-authorize-redirect-uri-not-allowed::{}",
req.redirect_uri
)));
}
if matches!(prompt, AuthorizePrompt::ForceLogin | AuthorizePrompt::Login) {
return self.restage_and_login_redirect(req).await;
}
let Some(user_id) = user_id else {
if prompt == AuthorizePrompt::NoInteraction {
return Err(interaction_required_error());
}
return self.restage_and_login_redirect(req).await;
};
let scopes = parse_request_scopes(req);
client.validate_scopes(&scopes)?;
if prompt == AuthorizePrompt::NoInteraction {
let tenant_id = current_tenant_id_with_warn();
if self
.consent_decision(tenant_id, user_id, &req.client_id, &scopes, &[])
.await?
!= ConsentDecision::Remembered
{
return Err(interaction_required_error());
}
return self.issue_authorization_code(req, &scopes, user_id).await;
}
self.continue_authorization(req, &scopes, user_id, &[])
.await
}
pub async fn resume(
&self,
ticket: &str,
user_id: Option<i64>,
attributes: &[ConsentAttributes],
) -> GarrisonResult<AuthorizeResponse> {
let key = authorize_ticket_key(ticket);
let json = self
.dao
.get_and_delete(&key)
.await?
.ok_or_else(ticket_invalid_error)?;
let req: AuthorizeRequest = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-ticket-deserialize::{}", e))
})?;
let Some(user_id) = user_id else {
return self.restage_and_login_redirect(&req).await;
};
let scopes = self.revalidate_staged(&req).await?;
self.continue_authorization(&req, &scopes, user_id, attributes)
.await
}
async fn restage_and_login_redirect(
&self,
req: &AuthorizeRequest,
) -> GarrisonResult<AuthorizeResponse> {
let ticket = self.stage_request(req).await?;
let return_to = format!("/oauth2/authorize/resume?ticket={}", ticket);
let login_url = format!(
"{}?return_to={}",
self.login_url,
utf8_percent_encode(&return_to, QUERY_VALUE_ENCODE_SET)
);
Ok(AuthorizeResponse::LoginRequired { login_url })
}
async fn stage_request(&self, req: &AuthorizeRequest) -> GarrisonResult<String> {
let ticket = generate_authorize_ticket();
let key = authorize_ticket_key(&ticket);
let json = serde_json::to_string(req).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-serialize::{}", e))
})?;
if !self
.dao
.set_if_absent(&key, &json, AUTHORIZE_TICKET_TTL_SECONDS)
.await?
{
return Err(GarrisonError::Internal(
"oauth2-server-authorize-ticket-collision".into(),
));
}
Ok(ticket)
}
async fn continue_authorization(
&self,
req: &AuthorizeRequest,
scopes: &[String],
user_id: i64,
attributes: &[ConsentAttributes],
) -> GarrisonResult<AuthorizeResponse> {
let tenant_id = current_tenant_id_with_warn();
match self
.consent_decision(tenant_id, user_id, &req.client_id, scopes, attributes)
.await?
{
ConsentDecision::Remembered => {
self.issue_authorization_code(req, scopes, user_id).await
},
ConsentDecision::Required(reason) => {
if matches!(reason, ConsentRequiredReason::FirstGrant) {
self.grant_consent(tenant_id, user_id, &req.client_id, scopes, attributes)
.await?;
return self.issue_authorization_code(req, scopes, user_id).await;
}
self.escalate_consent(req).await
},
}
}
async fn escalate_consent(&self, req: &AuthorizeRequest) -> GarrisonResult<AuthorizeResponse> {
let Some(consent_url) = &self.consent_url else {
return Err(interaction_required_error());
};
let ticket = self.stage_request(req).await?;
let sep = if consent_url.contains('?') { '&' } else { '?' };
let login_url = format!("{}{}ticket={}", consent_url, sep, ticket);
Ok(AuthorizeResponse::LoginRequired { login_url })
}
pub async fn consent_decision(
&self,
tenant_id: i64,
user_id: i64,
client_id: &str,
requested_scopes: &[String],
attributes: &[ConsentAttributes],
) -> GarrisonResult<ConsentDecision> {
let key = consent_key(tenant_id, user_id, client_id);
let Some(json) = self.dao.get(&key).await? else {
return Ok(ConsentDecision::Required(ConsentRequiredReason::FirstGrant));
};
let Ok(record) = serde_json::from_str::<ConsentRecord>(&json) else {
return Ok(ConsentDecision::Required(
ConsentRequiredReason::SnapshotUnreadable,
));
};
let new_scopes: Vec<String> = requested_scopes
.iter()
.filter(|s| !record.granted_scopes.contains(*s))
.cloned()
.collect();
if !new_scopes.is_empty() {
return Ok(ConsentDecision::Required(
ConsentRequiredReason::ScopeExpansion { new_scopes },
));
}
let names_changed = record.attribute_names_hash != attribute_names_hash(attributes);
let values_changed = record.attribute_values_hash != attribute_values_hash(attributes);
let attributes_changed = match self.attribute_granularity {
AttributeSnapshotGranularity::AttributeName => names_changed,
AttributeSnapshotGranularity::AttributeValue => names_changed || values_changed,
};
if attributes_changed {
return Ok(ConsentDecision::Required(
ConsentRequiredReason::AttributesChanged,
));
}
Ok(ConsentDecision::Remembered)
}
pub async fn grant_consent(
&self,
tenant_id: i64,
user_id: i64,
client_id: &str,
approved_scopes: &[String],
attributes: &[ConsentAttributes],
) -> GarrisonResult<Vec<String>> {
let key = consent_key(tenant_id, user_id, client_id);
let mut merged: Vec<String> = self
.dao
.get(&key)
.await?
.and_then(|json| serde_json::from_str::<ConsentRecord>(&json).ok())
.map(|r| r.granted_scopes)
.unwrap_or_default();
for scope in approved_scopes {
if !merged.contains(scope) {
merged.push(scope.clone());
}
}
merged.sort();
let record = ConsentRecord {
granted_scopes: merged.clone(),
attribute_names_hash: attribute_names_hash(attributes),
attribute_values_hash: attribute_values_hash(attributes),
};
let json = serde_json::to_string(&record).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-serialize::{}", e))
})?;
self.dao.set(&key, &json, 0).await?;
Ok(merged)
}
pub async fn resume_with_consent(
&self,
ticket: &str,
user_id: i64,
approved: bool,
attributes: &[ConsentAttributes],
) -> GarrisonResult<AuthorizeResponse> {
let key = authorize_ticket_key(ticket);
let json = self
.dao
.get_and_delete(&key)
.await?
.ok_or_else(ticket_invalid_error)?;
let req: AuthorizeRequest = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-ticket-deserialize::{}", e))
})?;
if !approved {
return Err(GarrisonError::OAuth2(
"oauth2-server-authorize-access-denied".into(),
));
}
let scopes = self.revalidate_staged(&req).await?;
let tenant_id = current_tenant_id_with_warn();
self.grant_consent(tenant_id, user_id, &req.client_id, &scopes, attributes)
.await?;
self.issue_authorization_code(&req, &scopes, user_id).await
}
async fn revalidate_staged(&self, req: &AuthorizeRequest) -> GarrisonResult<Vec<String>> {
let client = self.load_client(&req.client_id).await?;
if !client.is_redirect_uri_allowed(&req.redirect_uri) {
return Err(GarrisonError::OAuth2(format!(
"oauth2-server-authorize-redirect-uri-not-allowed::{}",
req.redirect_uri
)));
}
let scopes = parse_request_scopes(req);
client.validate_scopes(&scopes)?;
Ok(scopes)
}
async fn issue_authorization_code(
&self,
req: &AuthorizeRequest,
scopes: &[String],
user_id: i64,
) -> GarrisonResult<AuthorizeResponse> {
let code = generate_authorization_code();
let auth_code = AuthorizationCode {
code: code.clone(),
client_id: req.client_id.clone(),
redirect_uri: req.redirect_uri.clone(),
scopes: scopes.to_vec(),
user_id,
code_challenge: req.code_challenge.clone(),
};
let key = DaoKeyPrefix::OAuth2AuthCode.build_key(&code);
let json = serde_json::to_string(&auth_code).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-serialize::{}", e))
})?;
self.dao.set(&key, &json, AUTH_CODE_TTL_SECONDS).await?;
let sep = if req.redirect_uri.contains('?') {
'&'
} else {
'?'
};
let mut location = format!("{}{}code={}", req.redirect_uri, sep, code);
if let Some(state) = &req.state {
location.push_str("&state=");
location.push_str(&utf8_percent_encode(state, QUERY_VALUE_ENCODE_SET).to_string());
}
Ok(AuthorizeResponse::Redirect { location })
}
async fn load_client(
&self,
client_id: &str,
) -> GarrisonResult<crate::oauth2_server::client::OAuth2Client> {
self.store.get(client_id).await?.ok_or_else(|| {
GarrisonError::OAuth2(format!("oauth2-server-client-id-invalid::{}", client_id))
})
}
pub async fn consume_code(&self, code: &str) -> GarrisonResult<Option<AuthorizationCode>> {
let key = DaoKeyPrefix::OAuth2AuthCode.build_key(code);
let json = self.dao.get_and_delete(&key).await?;
match json {
Some(json) => {
let auth_code: AuthorizationCode = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-deserialize::{}", e))
})?;
Ok(Some(auth_code))
},
None => Ok(None),
}
}
pub async fn record_code_tokens(
&self,
code: &str,
access_token: &str,
refresh_token: Option<&str>,
) -> GarrisonResult<()> {
let key = DaoKeyPrefix::OAuth2CodeUsed.build_key(code);
let record = CodeUsedRecord {
access_token: access_token.to_string(),
refresh_token: refresh_token.map(|s| s.to_string()),
};
let json = serde_json::to_string(&record).map_err(|e| {
GarrisonError::Internal(format!("oauth2-server-authorize-serialize::{}", e))
})?;
self.dao
.set(&key, &json, CODE_USED_RECORD_TTL_SECONDS)
.await
}
pub async fn revoke_replayed_code_tokens(&self, code: &str) -> GarrisonResult<bool> {
let key = DaoKeyPrefix::OAuth2CodeUsed.build_key(code);
let json = self.dao.get_and_delete(&key).await?;
let Some(json) = json else {
return Ok(false);
};
let record: CodeUsedRecord = match serde_json::from_str(&json) {
Ok(r) => r,
Err(e) => {
tracing::warn!(error = %e, "revoke_replayed_code_tokens: failed to deserialize codeused record, skipping revocation");
return Ok(false);
},
};
let at_key = DaoKeyPrefix::OAuth2AccessToken.build_key(&record.access_token);
if let Err(e) = self.dao.delete(&at_key).await {
tracing::warn!(error = %e, "revoke_replayed_code_tokens: failed to delete access token record");
}
if let Some(rt) = &record.refresh_token {
let rt_key = oauth2_refresh_token_key(rt);
if let Err(e) = self.dao.delete(&rt_key).await {
tracing::warn!(error = %e, "revoke_replayed_code_tokens: failed to delete refresh token record");
}
}
Ok(true)
}
}
fn validate_request_shape(req: &AuthorizeRequest) -> GarrisonResult<()> {
if req.response_type != "code" {
return Err(GarrisonError::OAuth2(format!(
"oauth2-server-authorize-unsupported-response-type::{}",
req.response_type
)));
}
if req.code_challenge_method != "S256" {
return Err(GarrisonError::OAuth2(format!(
"oauth2-server-authorize-unsupported-code-challenge-method::{}",
req.code_challenge_method
)));
}
if req.code_challenge.is_empty() {
return Err(GarrisonError::OAuth2(
"oauth2-server-authorize-code-challenge-empty".into(),
));
}
Ok(())
}
fn parse_request_scopes(req: &AuthorizeRequest) -> Vec<String> {
req.scope
.as_ref()
.map(|s| s.split_whitespace().map(|x| x.to_string()).collect())
.unwrap_or_default()
}
fn generate_authorization_code() -> String {
let mut bytes = [0u8; 32];
getrandom::fill(&mut bytes).expect("OS CSPRNG 不可用");
URL_SAFE_NO_PAD.encode(bytes)
}
impl AuthorizeHandler {
pub async fn reconcile_consents(&self) -> GarrisonResult<(usize, usize)> {
let alive: std::collections::HashSet<String> = self
.store
.list()
.await?
.into_iter()
.map(|c| c.client_id)
.collect();
let pattern = format!("{OAUTH2_CONSENT_KEY_PREFIX}*");
let mut removed = 0;
let mut kept = 0;
for key in self.dao.keys(&pattern).await? {
let Some(rest) = key.strip_prefix(OAUTH2_CONSENT_KEY_PREFIX) else {
continue;
};
let mut parts = rest.splitn(3, ':');
let Some(client_id) = parts.nth(2) else {
continue;
};
if alive.contains(client_id) {
kept += 1;
} else {
self.dao.delete(&key).await?;
removed += 1;
}
}
Ok((removed, kept))
}
}
fn generate_authorize_ticket() -> String {
use rand::distr::{Alphanumeric, SampleString};
Alphanumeric.sample_string(&mut rand::rng(), AUTHORIZE_TICKET_LEN)
}
fn sha512_hex(data: &[u8]) -> String {
let mut hasher = Sha512::new();
hasher.update(data);
hasher
.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect()
}
fn attribute_names_hash(attributes: &[ConsentAttributes]) -> String {
let mut names: Vec<&str> = attributes.iter().map(|(name, _)| name.as_str()).collect();
names.sort();
sha512_hex(names.join("|").as_bytes())
}
fn attribute_values_hash(attributes: &[ConsentAttributes]) -> String {
let mut sorted: Vec<&ConsentAttributes> = attributes.iter().collect();
sorted.sort_by(|a, b| a.0.cmp(&b.0));
let per_attr: Vec<String> = sorted.iter().map(|(_, values)| values.join("")).collect();
sha512_hex(per_attr.join("|").as_bytes())
}
pub fn generate_code_challenge(code_verifier: &str) -> String {
let mut hasher = Sha256::new();
hasher.update(code_verifier.as_bytes());
let digest = hasher.finalize();
URL_SAFE_NO_PAD.encode(digest)
}
pub fn is_valid_code_verifier_len(code_verifier: &str) -> bool {
(CODE_VERIFIER_MIN_LEN..=CODE_VERIFIER_MAX_LEN).contains(&code_verifier.len())
}
pub fn verify_pkce(code_verifier: &str, code_challenge: &str) -> GarrisonResult<bool> {
if !is_valid_code_verifier_len(code_verifier) {
return Err(GarrisonError::OAuth2(format!(
"oauth2-server-authorize-code-verifier-invalid-length::{}",
code_verifier.len()
)));
}
if code_challenge.len() != S256_CHALLENGE_LEN {
return Ok(false);
}
let computed = generate_code_challenge(code_verifier);
Ok(crate::secure::ct_eq::constant_time_eq(
computed.as_bytes(),
code_challenge.as_bytes(),
))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
use crate::oauth2_server::client::{GrantType, OAuth2Client};
fn make_test_client(id: &str) -> OAuth2Client {
OAuth2Client::new(
id,
"secret-123",
vec!["https://app.example.com/cb".into()],
vec![GrantType::AuthorizationCode],
vec!["read".into()],
)
.unwrap()
}
fn make_handler() -> (AuthorizeHandler, Arc<InMemoryDao>) {
let dao = Arc::new(InMemoryDao::new());
let store = Arc::new(crate::oauth2_server::client::DaoOAuth2ClientStore::new(
dao.clone(),
));
let handler =
AuthorizeHandler::new(store, dao.clone(), "https://auth.example.com/login".into());
(handler, dao)
}
fn make_request(client_id: &str, code_challenge: &str) -> AuthorizeRequest {
AuthorizeRequest {
response_type: "code".into(),
client_id: client_id.into(),
redirect_uri: "https://app.example.com/cb".into(),
scope: Some("read".into()),
state: Some("xyz".into()),
code_challenge: code_challenge.into(),
code_challenge_method: "S256".into(),
prompt: None,
}
}
#[test]
fn generate_code_challenge_matches_rfc7636_example() {
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let expected = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";
assert_eq!(generate_code_challenge(verifier), expected);
}
#[test]
fn verify_pkce_matches() {
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
assert!(verify_pkce(verifier, &challenge).unwrap());
}
#[test]
fn verify_pkce_mismatch() {
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let wrong_challenge = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";
let other = generate_code_challenge("other-verifier-other-verifier-other-verifier");
assert!(!verify_pkce(verifier, &other).unwrap());
let _ = wrong_challenge;
}
#[test]
fn verify_pkce_rejects_short_verifier() {
let err = verify_pkce("short", "challenge").unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[test]
fn verify_pkce_rejects_long_verifier() {
let verifier = "a".repeat(129);
let err = verify_pkce(&verifier, "challenge").unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[test]
fn is_valid_code_verifier_len_boundary() {
assert!(!is_valid_code_verifier_len(&"a".repeat(42)));
assert!(is_valid_code_verifier_len(&"a".repeat(43)));
assert!(is_valid_code_verifier_len(&"a".repeat(128)));
assert!(!is_valid_code_verifier_len(&"a".repeat(129)));
}
#[tokio::test]
async fn authorize_success() {
let (handler, _) = make_handler();
let client = make_test_client("auth-001");
handler.store.create(client).await.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("auth-001", &challenge);
let resp = handler.authorize(&req, Some(1001)).await.expect("授权");
match resp {
AuthorizeResponse::Redirect { location } => {
assert!(location.starts_with("https://app.example.com/cb?code="));
assert!(location.contains("state=xyz"));
},
_ => panic!("期望 Redirect"),
}
}
#[tokio::test]
async fn authorize_unlogged_redirects_to_login() {
let (handler, _) = make_handler();
let client = make_test_client("auth-002");
handler.store.create(client).await.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("auth-002", &challenge);
let resp = handler.authorize(&req, None).await.expect("授权");
match resp {
AuthorizeResponse::LoginRequired { login_url } => {
assert!(login_url.starts_with("https://auth.example.com/login?return_to="));
},
_ => panic!("期望 LoginRequired"),
}
}
#[tokio::test]
async fn authorize_invalid_client_id() {
let (handler, _) = make_handler();
let req = make_request("no-such-client", "challenge");
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[tokio::test]
async fn authorize_invalid_redirect_uri() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-003"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let mut req = make_request("auth-003", &challenge);
req.redirect_uri = "https://evil.example.com/cb".into();
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[tokio::test]
async fn authorize_unsupported_response_type() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-004"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let mut req = make_request("auth-004", &challenge);
req.response_type = "token".into();
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[tokio::test]
async fn authorize_unsupported_code_challenge_method() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-005"))
.await
.unwrap();
let req = make_request("auth-005", "challenge");
let mut req = req;
req.code_challenge_method = "plain".into();
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[tokio::test]
async fn authorize_empty_code_challenge() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-006"))
.await
.unwrap();
let req = make_request("auth-006", "");
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(matches!(err, GarrisonError::OAuth2(_)));
}
#[tokio::test]
async fn authorize_without_state() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-007"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let mut req = make_request("auth-007", &challenge);
req.state = None;
let resp = handler.authorize(&req, Some(1)).await.unwrap();
match resp {
AuthorizeResponse::Redirect { location } => {
assert!(!location.contains("state="));
},
_ => panic!("期望 Redirect"),
}
}
#[tokio::test]
async fn authorize_return_to_carries_only_resume_ticket() {
let (handler, dao) = make_handler();
let client = OAuth2Client::new(
"auth-encode-001",
"secret-123",
vec!["https://app.example.com/cb?existing=param".into()],
vec![GrantType::AuthorizationCode],
vec!["read".into()],
)
.unwrap();
handler.store.create(client).await.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = AuthorizeRequest {
response_type: "code".into(),
client_id: "auth-encode-001".into(),
redirect_uri: "https://app.example.com/cb?existing=param".into(),
scope: Some("read".into()),
state: Some("state&with&s".into()),
code_challenge: challenge,
code_challenge_method: "S256".into(),
prompt: None,
};
let resp = handler
.authorize(&req, None)
.await
.expect("应返回 LoginRequired");
match resp {
AuthorizeResponse::LoginRequired { login_url } => {
let return_to_part = login_url
.split("return_to=")
.nth(1)
.expect("应包含 return_to 参数");
assert!(
return_to_part.contains("authorize%2Fresume")
|| return_to_part.contains("authorize/resume"),
"return_to 应指向 resume 续流地址: {}",
login_url
);
assert!(
!return_to_part.contains("redirect_uri"),
"return_to 不得携带 redirect_uri(票据化后由暂存恢复): {}",
login_url
);
assert!(
!return_to_part.contains("state"),
"return_to 不得携带 state: {}",
login_url
);
let ticket = return_to_part
.rsplit("ticket%3D")
.next()
.or_else(|| return_to_part.rsplit("ticket=").next())
.expect("return_to 应携带票据参数");
assert_eq!(
ticket.len(),
32,
"票据应为 32 字符,实际 {} 字符: {}",
ticket.len(),
login_url
);
assert!(
ticket.chars().all(|c| c.is_ascii_alphanumeric()),
"票据应为纯字母数字: {}",
login_url
);
let staged = dao
.keys("oauth2:authorize-ticket:*")
.await
.expect("keys 扫描");
assert_eq!(staged.len(), 1, "应恰好暂存一张票据");
},
_ => panic!("期望 LoginRequired"),
}
}
#[tokio::test]
async fn authorize_not_logged_in_stages_full_request_with_600s_ttl() {
let (handler, dao) = make_handler();
handler
.store
.create(make_test_client("ticket-001"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("ticket-001", &challenge);
let resp = handler.authorize(&req, None).await.expect("授权");
let login_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let staged = dao
.keys("oauth2:authorize-ticket:*")
.await
.expect("keys 扫描");
assert_eq!(staged.len(), 1, "应恰好暂存一张票据");
let key = &staged[0];
let json = dao.get(key).await.unwrap().expect("暂存应存在");
let staged_req: AuthorizeRequest = serde_json::from_str(&json).expect("应可反序列化");
assert_eq!(staged_req.client_id, req.client_id);
assert_eq!(staged_req.redirect_uri, req.redirect_uri);
assert_eq!(staged_req.scope, req.scope);
assert_eq!(staged_req.state, req.state);
assert_eq!(staged_req.code_challenge, req.code_challenge);
assert_eq!(staged_req.response_type, req.response_type);
assert_eq!(staged_req.code_challenge_method, req.code_challenge_method);
let ttl = dao.get_timeout(key).await.unwrap().expect("应设置 TTL");
assert!(
ttl.as_secs() <= 600 && ttl.as_secs() > 590,
"TTL 应为 600s 量级,实际 {:?}",
ttl
);
let ticket = extract_ticket_from_login_url(&login_url);
assert_eq!(
key,
&format!("oauth2:authorize-ticket:{}", ticket),
"return_to 中的票据应与暂存键一致: {}",
login_url
);
}
#[tokio::test]
async fn resume_restores_full_request_and_issues_code() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("ticket-002"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("ticket-002", &challenge);
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let ticket = extract_ticket_from_login_url(&login_url);
let resp = handler
.resume(&ticket, Some(4001), &[])
.await
.expect("resume");
let location = match resp {
AuthorizeResponse::Redirect { location } => location,
_ => panic!("期望 Redirect"),
};
assert!(location.contains("state=xyz"), "state 应原样回传");
let code = location
.split("code=")
.nth(1)
.unwrap()
.split('&')
.next()
.unwrap();
let auth_code = handler.consume_code(code).await.unwrap().expect("应存在");
assert_eq!(auth_code.client_id, "ticket-002");
assert_eq!(auth_code.user_id, 4001);
assert_eq!(auth_code.redirect_uri, "https://app.example.com/cb");
assert_eq!(auth_code.scopes, vec!["read".to_string()]);
assert_eq!(auth_code.code_challenge, challenge);
}
#[tokio::test]
async fn resume_rejects_unknown_or_expired_ticket() {
let (handler, _) = make_handler();
let err = handler
.resume("totally-unknown-ticket-0123456789ab", Some(1), &[])
.await
.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-ticket-invalid-or-expired"),
"期望票据无效/过期错误,实际: {}",
err
);
}
#[tokio::test]
async fn resume_rejects_second_consumption_of_same_ticket() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("ticket-003"))
.await
.unwrap();
let req = make_request(
"ticket-003",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let ticket = extract_ticket_from_login_url(&login_url);
assert!(handler.resume(&ticket, Some(4002), &[]).await.is_ok());
let err = handler.resume(&ticket, Some(4002), &[]).await.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-ticket-invalid-or-expired"),
"二次消费应拒绝,实际: {}",
err
);
}
#[tokio::test]
async fn resume_rejects_ticket_after_ttl_expiry() {
let (handler, dao) = make_handler();
let req = make_request("ticket-004", "challenge");
let json = serde_json::to_string(&req).unwrap();
let key = "oauth2:authorize-ticket:expiring-ticket-0123456789012345";
assert!(dao.set_if_absent(key, &json, 1).await.unwrap());
tokio::time::sleep(std::time::Duration::from_millis(1200)).await;
let ticket = key.rsplit(':').next().unwrap();
let err = handler.resume(ticket, Some(4003), &[]).await.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-ticket-invalid-or-expired"),
"过期票据应拒绝,实际: {}",
err
);
}
#[tokio::test]
async fn resume_without_login_reissues_fresh_ticket() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("ticket-005"))
.await
.unwrap();
let req = make_request(
"ticket-005",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let first_ticket = extract_ticket_from_login_url(&login_url);
let resp = handler.resume(&first_ticket, None, &[]).await.unwrap();
let second_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let second_ticket = extract_ticket_from_login_url(&second_url);
assert_ne!(
first_ticket, second_ticket,
"重新暂存必须签发新票据(旧票据已消费)"
);
assert!(handler
.resume(&first_ticket, Some(4004), &[])
.await
.is_err());
assert!(handler
.resume(&second_ticket, Some(4004), &[])
.await
.is_ok());
}
fn extract_ticket_from_login_url(login_url: &str) -> String {
let return_to = login_url.split("return_to=").nth(1).expect("含 return_to");
let decoded = percent_encoding::percent_decode_str(return_to)
.decode_utf8()
.expect("return_to 应为合法 UTF-8");
decoded
.rsplit("ticket=")
.next()
.expect("return_to 应含 ticket")
.to_string()
}
fn make_test_client_with_scopes(id: &str, scopes: &[&str]) -> OAuth2Client {
OAuth2Client::new(
id,
"secret-123",
vec!["https://app.example.com/cb".into()],
vec![GrantType::AuthorizationCode],
scopes.iter().map(|s| s.to_string()).collect(),
)
.unwrap()
}
fn make_handler_with_consent_url() -> (AuthorizeHandler, Arc<InMemoryDao>) {
let (handler, dao) = make_handler();
let handler = handler.with_consent_url("https://auth.example.com/consent".into());
(handler, dao)
}
#[tokio::test]
async fn grant_consent_merges_superset_and_only_grows() {
let (handler, dao) = make_handler();
let merged = handler
.grant_consent(0, 5001, "consent-001", &["read".into()], &[])
.await
.unwrap();
assert_eq!(merged, vec!["read".to_string()]);
let merged = handler
.grant_consent(
0,
5001,
"consent-001",
&["write".into(), "read".into()],
&[],
)
.await
.unwrap();
assert_eq!(merged, vec!["read".to_string(), "write".to_string()]);
let merged = handler
.grant_consent(0, 5001, "consent-001", &["read".into()], &[])
.await
.unwrap();
assert_eq!(merged, vec!["read".to_string(), "write".to_string()]);
let key = "oauth2:consent:0:5001:consent-001";
assert!(
dao.get(key).await.unwrap().is_some(),
"consent 记录应持久化于 (tenant,user,client) 键"
);
}
#[tokio::test]
async fn consent_decision_subset_of_granted_is_remembered() {
let (handler, _) = make_handler();
handler
.grant_consent(
0,
5002,
"consent-002",
&["read".into(), "write".into()],
&[],
)
.await
.unwrap();
let d = handler
.consent_decision(0, 5002, "consent-002", &["read".into()], &[])
.await
.unwrap();
assert_eq!(d, ConsentDecision::Remembered, "子集请求应免征询");
}
#[tokio::test]
async fn consent_decision_new_scope_requires_consent_listing_new_scopes() {
let (handler, _) = make_handler();
handler
.grant_consent(0, 5003, "consent-003", &["read".into()], &[])
.await
.unwrap();
let d = handler
.consent_decision(
0,
5003,
"consent-003",
&["read".into(), "admin".into()],
&[],
)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::ScopeExpansion {
new_scopes: vec!["admin".to_string()],
}),
"新增 scope 应触发重征询并列出增量"
);
}
#[tokio::test]
async fn consent_decision_without_record_requires_first_grant() {
let (handler, _) = make_handler();
let d = handler
.consent_decision(0, 5004, "consent-004", &["read".into()], &[])
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::FirstGrant),
"无记录应为首次授权"
);
}
#[tokio::test]
async fn consent_records_are_tenant_scoped() {
let (handler, _) = make_handler();
handler
.grant_consent(7, 5005, "consent-005", &["read".into()], &[])
.await
.unwrap();
let d = handler
.consent_decision(7, 5005, "consent-005", &["read".into()], &[])
.await
.unwrap();
assert_eq!(d, ConsentDecision::Remembered);
let d = handler
.consent_decision(8, 5005, "consent-005", &["read".into()], &[])
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::FirstGrant),
"其他租户不得命中本租户 consent"
);
}
#[tokio::test]
async fn resume_with_insufficient_consent_escalates_then_merge_on_approval() {
let (handler, dao) = make_handler_with_consent_url();
handler
.store
.create(make_test_client_with_scopes(
"consent-006",
&["read", "admin"],
))
.await
.unwrap();
handler
.grant_consent(0, 5006, "consent-006", &["read".into()], &[])
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let mut req = make_request("consent-006", &generate_code_challenge(verifier));
req.scope = Some("read admin".into());
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let resp = handler
.resume(&extract_ticket_from_login_url(&login_url), Some(5006), &[])
.await
.unwrap();
let consent_page_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
other => panic!("期望升级征询页,实际: {:?}", other),
};
assert!(
consent_page_url.starts_with("https://auth.example.com/consent?ticket="),
"应重定向到征询页并携带重入票据: {}",
consent_page_url
);
let staged = dao
.keys("oauth2:authorize-ticket:*")
.await
.expect("keys 扫描");
assert_eq!(staged.len(), 1, "升级应签发恰好一张重入票据");
let new_ticket = consent_page_url.rsplit("ticket=").next().unwrap();
let resp = handler
.resume_with_consent(new_ticket, 5006, true, &[])
.await
.unwrap();
assert!(
matches!(resp, AuthorizeResponse::Redirect { .. }),
"批准后应放行"
);
let d = handler
.consent_decision(
0,
5006,
"consent-006",
&["read".into(), "admin".into()],
&[],
)
.await
.unwrap();
assert_eq!(d, ConsentDecision::Remembered, "批准后应合并为超集");
}
#[tokio::test]
async fn resume_with_consent_denied_is_access_denied_and_records_nothing() {
let (handler, _) = make_handler_with_consent_url();
handler
.store
.create(make_test_client_with_scopes(
"consent-007",
&["read", "admin"],
))
.await
.unwrap();
handler
.grant_consent(0, 5007, "consent-007", &["read".into()], &[])
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let mut req = make_request("consent-007", &generate_code_challenge(verifier));
req.scope = Some("read admin".into());
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let resp = handler
.resume(&extract_ticket_from_login_url(&login_url), Some(5007), &[])
.await
.unwrap();
let consent_page_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
other => panic!("期望升级征询页,实际: {:?}", other),
};
let new_ticket = consent_page_url.rsplit("ticket=").next().unwrap();
let err = handler
.resume_with_consent(new_ticket, 5007, false, &[])
.await
.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-access-denied"),
"拒绝应为 access_denied,实际: {}",
err
);
let d = handler
.consent_decision(0, 5007, "consent-007", &["read".into()], &[])
.await
.unwrap();
assert_eq!(d, ConsentDecision::Remembered);
let d = handler
.consent_decision(
0,
5007,
"consent-007",
&["read".into(), "admin".into()],
&[],
)
.await
.unwrap();
assert!(matches!(
d,
ConsentDecision::Required(ConsentRequiredReason::ScopeExpansion { .. })
));
}
#[tokio::test]
async fn continue_without_consent_url_errors_explicitly_when_escalation_needed() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client_with_scopes(
"consent-008",
&["read", "admin"],
))
.await
.unwrap();
handler
.grant_consent(0, 5008, "consent-008", &["read".into()], &[])
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let mut req = make_request("consent-008", &generate_code_challenge(verifier));
req.scope = Some("read admin".into());
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let err = handler
.resume(&extract_ticket_from_login_url(&login_url), Some(5008), &[])
.await
.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-interaction-required"),
"未配置征询页应显性失败,实际: {}",
err
);
}
#[tokio::test]
async fn authorize_direct_first_grant_records_consent_then_remembered() {
let (handler, dao) = make_handler();
handler
.store
.create(make_test_client("consent-009"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let req = make_request("consent-009", &generate_code_challenge(verifier));
let resp = handler.authorize(&req, Some(6001)).await.unwrap();
assert!(matches!(resp, AuthorizeResponse::Redirect { .. }));
let key = "oauth2:consent:0:6001:consent-009";
assert!(
dao.get(key).await.unwrap().is_some(),
"首次授权应记录 consent"
);
let resp = handler.authorize(&req, Some(6001)).await.unwrap();
assert!(matches!(resp, AuthorizeResponse::Redirect { .. }));
}
#[tokio::test]
async fn attribute_name_change_requires_reconsent() {
let (handler, _) = make_handler();
let attrs = vec![("email".to_string(), vec!["a@x".to_string()])];
handler
.grant_consent(0, 7001, "attr-001", &["read".into()], &attrs)
.await
.unwrap();
let d = handler
.consent_decision(0, 7001, "attr-001", &["read".into()], &attrs)
.await
.unwrap();
assert_eq!(d, ConsentDecision::Remembered);
let mut changed = attrs.clone();
changed.push(("uid".to_string(), vec!["u1".to_string()]));
let d = handler
.consent_decision(0, 7001, "attr-001", &["read".into()], &changed)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::AttributesChanged),
"属性名集合变化应触发重征询"
);
}
#[tokio::test]
async fn attribute_value_change_depends_on_granularity() {
let attrs_old = vec![("email".to_string(), vec!["a@x".to_string()])];
let attrs_new = vec![("email".to_string(), vec!["b@x".to_string()])];
let (handler, _) = make_handler();
handler
.grant_consent(0, 7002, "attr-002", &["read".into()], &attrs_old)
.await
.unwrap();
let d = handler
.consent_decision(0, 7002, "attr-002", &["read".into()], &attrs_new)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Remembered,
"名哈希粒度下属性值变化不应重征询"
);
let (handler, _) = make_handler();
let handler =
handler.with_attribute_granularity(AttributeSnapshotGranularity::AttributeValue);
handler
.grant_consent(0, 7003, "attr-003", &["read".into()], &attrs_old)
.await
.unwrap();
let d = handler
.consent_decision(0, 7003, "attr-003", &["read".into()], &attrs_new)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::AttributesChanged),
"值哈希粒度下属性值变化应触发重征询"
);
}
#[tokio::test]
async fn attribute_unchanged_remembered_under_both_granularities() {
let attrs = vec![
("email".to_string(), vec!["a@x".to_string()]),
("uid".to_string(), vec!["u1".to_string(), "u2".to_string()]),
];
for granularity in [
AttributeSnapshotGranularity::AttributeName,
AttributeSnapshotGranularity::AttributeValue,
] {
let (handler, _) = make_handler();
let handler = handler.with_attribute_granularity(granularity);
handler
.grant_consent(0, 7004, "attr-004", &["read".into()], &attrs)
.await
.unwrap();
let d = handler
.consent_decision(0, 7004, "attr-004", &["read".into()], &attrs)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Remembered,
"{:?} 粒度下属性不变应免征询",
granularity
);
}
}
#[tokio::test]
async fn corrupt_consent_record_failsafe_requires_reconsent() {
let (handler, dao) = make_handler();
dao.set("oauth2:consent:0:7005:attr-005", "{broken-json", 0)
.await
.unwrap();
let d = handler
.consent_decision(0, 7005, "attr-005", &["read".into()], &[])
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::SnapshotUnreadable),
"记录不可解析应 fail-safe 重征询"
);
}
#[test]
fn attribute_snapshot_hash_properties() {
let a = vec![
("email".to_string(), vec!["a@x".to_string()]),
("uid".to_string(), vec!["u1".to_string()]),
];
let a_reordered = vec![
("uid".to_string(), vec!["u1".to_string()]),
("email".to_string(), vec!["a@x".to_string()]),
];
let value_changed = vec![
("email".to_string(), vec!["b@x".to_string()]),
("uid".to_string(), vec!["u1".to_string()]),
];
let name_changed = vec![("email".to_string(), vec!["a@x".to_string()])];
for hash_fn in [attribute_names_hash, attribute_values_hash] {
let h1 = hash_fn(&a);
assert_eq!(h1.len(), 128, "SHA-512 十六进制应为 128 字符");
assert!(h1.chars().all(|c| c.is_ascii_hexdigit()));
assert_eq!(h1, hash_fn(&a), "同输入哈希必须确定");
assert_eq!(h1, hash_fn(&a_reordered), "输入顺序不得影响哈希");
}
assert_eq!(
attribute_names_hash(&a),
attribute_names_hash(&value_changed),
"名哈希不得受属性值影响"
);
assert_ne!(
attribute_names_hash(&a),
attribute_names_hash(&name_changed),
"名哈希必须反映名集合差异"
);
assert_ne!(
attribute_values_hash(&a),
attribute_values_hash(&value_changed),
"值哈希必须反映属性值差异"
);
}
#[tokio::test]
async fn consent_approval_persists_attribute_snapshot() {
let (handler, _) = make_handler_with_consent_url();
handler
.store
.create(make_test_client_with_scopes("attr-006", &["read", "admin"]))
.await
.unwrap();
handler
.grant_consent(0, 7006, "attr-006", &["read".into()], &[])
.await
.unwrap();
let attrs = vec![("email".to_string(), vec!["a@x".to_string()])];
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let mut req = make_request("attr-006", &generate_code_challenge(verifier));
req.scope = Some("read admin".into());
let login_url = match handler.authorize(&req, None).await.unwrap() {
AuthorizeResponse::LoginRequired { login_url } => login_url,
_ => panic!("期望 LoginRequired"),
};
let resp = handler
.resume(
&extract_ticket_from_login_url(&login_url),
Some(7006),
&attrs,
)
.await
.unwrap();
let consent_page_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
other => panic!("期望升级征询页,实际: {:?}", other),
};
let new_ticket = consent_page_url.rsplit("ticket=").next().unwrap();
handler
.resume_with_consent(new_ticket, 7006, true, &attrs)
.await
.unwrap();
let d = handler
.consent_decision(
0,
7006,
"attr-006",
&["read".into(), "admin".into()],
&attrs,
)
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Remembered,
"批准时的属性快照应覆盖后续同视图请求"
);
let d = handler
.consent_decision(0, 7006, "attr-006", &["read".into(), "admin".into()], &[])
.await
.unwrap();
assert_eq!(
d,
ConsentDecision::Required(ConsentRequiredReason::AttributesChanged),
"属性视图漂移应触发重征询"
);
}
#[tokio::test]
async fn reconcile_removes_orphan_consent_and_keeps_live() {
let (handler, dao) = make_handler();
handler
.store
.create(make_test_client("reconcile-live"))
.await
.unwrap();
handler
.store
.create(make_test_client("reconcile-dead"))
.await
.unwrap();
handler
.grant_consent(0, 8001, "reconcile-live", &["read".into()], &[])
.await
.unwrap();
handler
.grant_consent(0, 8002, "reconcile-dead", &["read".into()], &[])
.await
.unwrap();
handler.store.delete("reconcile-dead").await.unwrap();
let (removed, kept) = handler.reconcile_consents().await.unwrap();
assert_eq!(
removed, 1,
"应恰好清理 1 条孤儿记录,实际清理 {} 条",
removed
);
assert_eq!(kept, 1, "存活 client 的记录应保留,实际保留 {} 条", kept);
assert!(
dao.get("oauth2:consent:0:8002:reconcile-dead")
.await
.unwrap()
.is_none(),
"已删 client 的 consent 行应被清理"
);
assert!(
dao.get("oauth2:consent:0:8001:reconcile-live")
.await
.unwrap()
.is_some(),
"存活 client 的 consent 行应保留"
);
let (removed, _) = handler.reconcile_consents().await.unwrap();
assert_eq!(removed, 0, "reconcile 必须幂等");
}
#[tokio::test]
async fn prompt_none_with_valid_consent_passes_through() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("prompt-none-001"))
.await
.unwrap();
handler
.grant_consent(0, 8101, "prompt-none-001", &["read".into()], &[])
.await
.unwrap();
let req = make_request(
"prompt-none-001",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
let resp = handler
.authorize_with_prompt(&req, Some(8101), AuthorizePrompt::None)
.await
.expect("prompt=none + 有效 consent 应放行");
assert!(
matches!(resp, AuthorizeResponse::Redirect { .. }),
"应直接签发授权码"
);
}
#[tokio::test]
async fn prompt_none_without_consent_is_interaction_required() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client_with_scopes(
"prompt-none-002",
&["read", "admin"],
))
.await
.unwrap();
handler
.grant_consent(0, 8102, "prompt-none-002", &["read".into()], &[])
.await
.unwrap();
let mut req = make_request(
"prompt-none-002",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
req.scope = Some("read admin".into());
let err = handler
.authorize_with_prompt(&req, Some(8102), AuthorizePrompt::None)
.await
.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-interaction-required"),
"consent 不足应 interaction_required,实际: {}",
err
);
}
#[tokio::test]
async fn prompt_none_without_login_is_interaction_required() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("prompt-none-003"))
.await
.unwrap();
let req = make_request(
"prompt-none-003",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
let err = handler
.authorize_with_prompt(&req, None, AuthorizePrompt::NoInteraction)
.await
.unwrap_err();
assert!(
err.to_string()
.contains("oauth2-server-authorize-interaction-required"),
"未登录应 interaction_required,实际: {}",
err
);
}
#[tokio::test]
async fn prompt_login_forces_reauthentication_roundtrip() {
let (handler, dao) = make_handler();
handler
.store
.create(make_test_client("prompt-login-001"))
.await
.unwrap();
handler
.grant_consent(0, 8103, "prompt-login-001", &["read".into()], &[])
.await
.unwrap();
let req = make_request(
"prompt-login-001",
&generate_code_challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
);
let resp = handler
.authorize_with_prompt(&req, Some(8103), AuthorizePrompt::Login)
.await
.expect("prompt=login 应引导重新登录");
let login_url = match resp {
AuthorizeResponse::LoginRequired { login_url } => login_url,
other => panic!("期望 LoginRequired,实际: {:?}", other),
};
let ticket = extract_ticket_from_login_url(&login_url);
let staged = dao.keys("oauth2:authorize-ticket:*").await.unwrap();
assert_eq!(staged.len(), 1);
let resp = handler.resume(&ticket, Some(8103), &[]).await.unwrap();
assert!(matches!(resp, AuthorizeResponse::Redirect { .. }));
}
#[tokio::test]
async fn authorize_redirect_url_appends_code_with_ampersand_when_query_exists() {
let (handler, _) = make_handler();
let client = OAuth2Client::new(
"auth-encode-003",
"secret-123",
vec!["https://app.example.com/cb?existing=param".into()],
vec![GrantType::AuthorizationCode],
vec!["read".into()],
)
.unwrap();
handler.store.create(client).await.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = AuthorizeRequest {
response_type: "code".into(),
client_id: "auth-encode-003".into(),
redirect_uri: "https://app.example.com/cb?existing=param".into(),
scope: Some("read".into()),
state: Some("xyz".into()),
code_challenge: challenge,
code_challenge_method: "S256".into(),
prompt: None,
};
let resp = handler.authorize(&req, Some(1001)).await.expect("授权");
match resp {
AuthorizeResponse::Redirect { location } => {
assert!(location.starts_with("https://app.example.com/cb?existing=param&code="));
assert!(
!location.contains("?code="),
"不得出现双 ? 畸形 URL: {}",
location
);
assert!(location.ends_with("&state=xyz"));
},
_ => panic!("期望 Redirect"),
}
}
#[tokio::test]
async fn authorize_redirect_url_encodes_state() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-encode-002"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = AuthorizeRequest {
response_type: "code".into(),
client_id: "auth-encode-002".into(),
redirect_uri: "https://app.example.com/cb".into(),
scope: Some("read".into()),
state: Some("state&with=special#chars".into()),
code_challenge: challenge,
code_challenge_method: "S256".into(),
prompt: None,
};
let resp = handler.authorize(&req, Some(1001)).await.expect("授权");
match resp {
AuthorizeResponse::Redirect { location } => {
assert!(
!location.contains("state&with=special#chars"),
"state 中的特殊字符未被编码: {}",
location
);
assert!(location.contains("state="), "应有 state 参数: {}", location);
},
_ => panic!("期望 Redirect"),
}
}
#[tokio::test]
async fn authorize_scope_not_allowed() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-scope-001"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let mut req = make_request("auth-scope-001", &challenge);
req.scope = Some("admin".into());
let err = handler.authorize(&req, Some(1)).await.unwrap_err();
assert!(
err.to_string().contains(&crate::i18n::translate_detail(
"oauth2-server-client-invalid-scope",
&[("arg0", "admin")],
)),
"期望 invalid_scope 错误,实际: {}",
err
);
}
#[tokio::test]
async fn authorize_scope_allowed() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("auth-scope-002"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let mut req = make_request("auth-scope-002", &challenge);
req.scope = Some("read".into());
let resp = handler.authorize(&req, Some(1)).await.unwrap();
assert!(matches!(resp, AuthorizeResponse::Redirect { .. }));
}
#[tokio::test]
async fn consume_code_returns_auth_data() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("consume-001"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("consume-001", &challenge);
let resp = handler.authorize(&req, Some(2001)).await.unwrap();
let location = match resp {
AuthorizeResponse::Redirect { location } => location,
_ => panic!("期望 Redirect"),
};
let code = location
.split("code=")
.nth(1)
.unwrap()
.split('&')
.next()
.unwrap();
let auth_code = handler.consume_code(code).await.unwrap().expect("应存在");
assert_eq!(auth_code.client_id, "consume-001");
assert_eq!(auth_code.user_id, 2001);
assert_eq!(auth_code.code_challenge, challenge);
}
#[tokio::test]
async fn consume_code_one_time_use() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("consume-002"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("consume-002", &challenge);
let resp = handler.authorize(&req, Some(2002)).await.unwrap();
let location = match resp {
AuthorizeResponse::Redirect { location } => location,
_ => panic!("期望 Redirect"),
};
let code = location
.split("code=")
.nth(1)
.unwrap()
.split('&')
.next()
.unwrap();
assert!(handler.consume_code(code).await.unwrap().is_some());
assert!(handler.consume_code(code).await.unwrap().is_none());
}
#[tokio::test]
async fn consume_code_nonexistent_returns_none() {
let (handler, _) = make_handler();
let result = handler.consume_code("nonexistent-code").await.unwrap();
assert!(result.is_none());
}
#[tokio::test]
async fn consume_code_atomic_concurrent_only_one_wins() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("consume-conc-001"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("consume-conc-001", &challenge);
let resp = handler.authorize(&req, Some(3001)).await.unwrap();
let location = match resp {
AuthorizeResponse::Redirect { location } => location,
_ => panic!("期望 Redirect"),
};
let code = location
.split("code=")
.nth(1)
.unwrap()
.split('&')
.next()
.unwrap()
.to_string();
let handler = std::sync::Arc::new(handler);
let mut handles = Vec::new();
for _ in 0..16 {
let h = handler.clone();
let c = code.clone();
handles.push(tokio::spawn(async move {
h.consume_code(&c).await.unwrap().is_some()
}));
}
let mut wins = 0usize;
for h in handles {
if h.await.unwrap() {
wins += 1;
}
}
assert_eq!(
wins, 1,
"并发双花:仅一个 consume_code 应成功,实际 {}",
wins
);
}
#[tokio::test]
async fn revoke_replayed_code_tokens_deletes_records() {
let (handler, _) = make_handler();
handler
.store
.create(make_test_client("revoke-001"))
.await
.unwrap();
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = generate_code_challenge(verifier);
let req = make_request("revoke-001", &challenge);
let resp = handler.authorize(&req, Some(3002)).await.unwrap();
let location = match resp {
AuthorizeResponse::Redirect { location } => location,
_ => panic!("期望 Redirect"),
};
let code = location
.split("code=")
.nth(1)
.unwrap()
.split('&')
.next()
.unwrap()
.to_string();
assert!(handler.consume_code(&code).await.unwrap().is_some());
handler
.record_code_tokens(&code, "at-fake-001", Some("rt-fake-001"))
.await
.unwrap();
assert!(handler.consume_code(&code).await.unwrap().is_none());
let revoked = handler.revoke_replayed_code_tokens(&code).await.unwrap();
assert!(revoked, "应检测到 codeused 记录并吊销 token");
let at_key = crate::constants::DaoKeyPrefix::OAuth2AccessToken.build_key("at-fake-001");
assert!(
handler.dao.get(&at_key).await.unwrap().is_none(),
"access token 记录应已被吊销删除"
);
let rt_key = oauth2_refresh_token_key("rt-fake-001");
assert!(
handler.dao.get(&rt_key).await.unwrap().is_none(),
"refresh token 记录应已被吊销删除"
);
let revoked_again = handler.revoke_replayed_code_tokens(&code).await.unwrap();
assert!(!revoked_again, "codeused 记录应已消费删除");
}
#[test]
fn generate_authorization_code_produces_unique() {
let code1 = generate_authorization_code();
let code2 = generate_authorization_code();
assert_ne!(code1, code2);
assert!(code1.len() >= 43); }
}
#[cfg(test)]
mod prompt_and_error_tests {
use super::*;
fn make_req(prompt: Option<&str>) -> AuthorizeRequest {
AuthorizeRequest {
response_type: "code".into(),
client_id: "c1".into(),
redirect_uri: "https://app.example.com/cb".into(),
scope: Some("read".into()),
state: Some("xyz".into()),
code_challenge: "challenge-001".into(),
code_challenge_method: "S256".into(),
prompt: prompt.map(str::to_string),
}
}
#[test]
fn prompt_hint_parses_none_login_and_alias() {
assert_eq!(
make_req(None).prompt_hint(),
AuthorizePrompt::None,
"缺省 → 默认流程"
);
assert_eq!(
make_req(Some("none")).prompt_hint(),
AuthorizePrompt::NoInteraction
);
assert_eq!(
make_req(Some("login")).prompt_hint(),
AuthorizePrompt::ForceLogin
);
assert_eq!(
make_req(Some("consent")).prompt_hint(),
AuthorizePrompt::None,
"未知值 → 默认流程"
);
assert_eq!(
make_req(Some(" login ")).prompt_hint(),
AuthorizePrompt::ForceLogin,
"值应先 trim 再匹配"
);
}
#[test]
fn ticket_and_interaction_errors_use_stable_oauth2_codes() {
let err = ticket_invalid_error();
assert!(
matches!(&err, GarrisonError::OAuth2(m) if m.contains("ticket-invalid-or-expired")),
"ticket 失效应报稳定的 OAuth2 错误码,实际: {err:?}"
);
let err = interaction_required_error();
assert!(
matches!(&err, GarrisonError::OAuth2(m) if m.contains("interaction-required")),
"prompt=none 交互禁止应报 interaction-required,实际: {err:?}"
);
}
#[tokio::test]
async fn current_tenant_falls_back_to_zero_without_context() {
assert_eq!(current_tenant_id_with_warn(), 0);
}
}