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 rand::RngCore;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::sync::Arc;
const AUTH_CODE_TTL_SECONDS: u64 = 600;
const CODE_VERIFIER_MIN_LEN: usize = 43;
const CODE_VERIFIER_MAX_LEN: usize = 128;
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, 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,
}
#[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,
}
pub struct AuthorizeHandler {
store: Arc<dyn OAuth2ClientStore>,
dao: Arc<dyn GarrisonDao>,
login_url: String,
}
impl AuthorizeHandler {
pub fn new(
store: Arc<dyn OAuth2ClientStore>,
dao: Arc<dyn GarrisonDao>,
login_url: String,
) -> Self {
Self {
store,
dao,
login_url,
}
}
pub async fn authorize(
&self,
req: &AuthorizeRequest,
user_id: Option<i64>,
) -> GarrisonResult<AuthorizeResponse> {
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(),
));
}
let client = self.store.get(&req.client_id).await?.ok_or_else(|| {
GarrisonError::OAuth2(format!("invalid client_id: {}", req.client_id))
})?;
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 user_id = match user_id {
Some(id) => id,
None => {
let return_to = format!(
"/oauth2/authorize?client_id={}&redirect_uri={}&response_type=code&code_challenge={}&code_challenge_method=S256",
utf8_percent_encode(&req.client_id, QUERY_VALUE_ENCODE_SET),
utf8_percent_encode(&req.redirect_uri, QUERY_VALUE_ENCODE_SET),
utf8_percent_encode(&req.code_challenge, QUERY_VALUE_ENCODE_SET),
);
let login_url = format!(
"{}?return_to={}",
self.login_url,
utf8_percent_encode(&return_to, QUERY_VALUE_ENCODE_SET)
);
return Ok(AuthorizeResponse::LoginRequired { login_url });
},
};
let scopes: Vec<String> = req
.scope
.as_ref()
.map(|s| s.split_whitespace().map(|x| x.to_string()).collect())
.unwrap_or_default();
client.validate_scopes(&scopes)?;
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,
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 mut location = format!("{}?code={}", req.redirect_uri, 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 })
}
pub async fn consume_code(&self, code: &str) -> GarrisonResult<Option<AuthorizationCode>> {
let key = DaoKeyPrefix::OAuth2AuthCode.build_key(code);
let json = self.dao.get(&key).await?;
match json {
Some(json) => {
self.dao.delete(&key).await?;
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),
}
}
}
fn generate_authorization_code() -> String {
let mut bytes = [0u8; 32];
rand::thread_rng().fill_bytes(&mut bytes);
URL_SAFE_NO_PAD.encode(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()
)));
}
let computed = generate_code_challenge(code_verifier);
Ok(computed == code_challenge)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::MockDao;
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<MockDao>) {
let dao = Arc::new(MockDao::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(),
}
}
#[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_encodes_redirect_uri_with_ampersand() {
let (handler, _) = 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(),
};
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("redirect_uri=https"),
"return_to 中 redirect_uri 的 = 或值未编码,存在参数注入风险: {}",
login_url
);
assert!(
!return_to_part.contains("state&with&s"),
"state 中的 & 未被编码: {}",
login_url
);
assert!(
return_to_part.contains("%26") || return_to_part.contains("%2526"),
"return_to 应包含编码后的 & 字符: {}",
login_url
);
},
_ => panic!("期望 LoginRequired"),
}
}
#[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(),
};
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("oauth2-server-client-invalid-scope"),
"期望 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());
}
#[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); }
}