use crate::auth::types::{ClientRegistration, ServerMetadata, TokenResponse, TokenSet};
use crate::core::transport::{HttpClient, HttpPurpose};
use crate::shared::errors::{Error, Result};
use chrono::Utc;
use sha2::{Digest, Sha256};
use std::time::Duration;
const AUTH_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Clone)]
pub struct OAuthTokenEndpointError {
pub status: u16,
pub oauth_error: String,
pub error_description: String,
}
impl std::fmt::Display for OAuthTokenEndpointError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "token: HTTP {}", self.status)
}
}
impl std::error::Error for OAuthTokenEndpointError {}
pub fn is_invalid_grant_error(err: &Error) -> bool {
matches!(err, Error::OAuthTokenEndpoint(e) if e.oauth_error == "invalid_grant")
}
pub fn is_ssl_error(msg: &str) -> bool {
msg.contains("tls:") || msg.contains("x509:") || msg.contains("certificate")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OAuthMetadataProfile {
Desktop,
Web,
}
impl OAuthMetadataProfile {
pub fn as_str(self) -> &'static str {
match self {
OAuthMetadataProfile::Desktop => "desktop",
OAuthMetadataProfile::Web => "web",
}
}
}
pub async fn discover_with_profile_with_transport(
http: &HttpClient,
server_url: &str,
profile: OAuthMetadataProfile,
) -> Result<ServerMetadata> {
let trimmed = server_url.trim_end_matches('/');
let parsed = url::Url::parse(trimmed)
.map_err(|e| Error::other(format!("discover: invalid server URL: {e}")))?;
let host = parsed
.host_str()
.ok_or_else(|| Error::other("discover: invalid server URL: missing host"))?;
let mut origin = format!("{}://{}", parsed.scheme(), host);
if let Some(port) = parsed.port() {
origin.push_str(&format!(":{port}"));
}
let endpoint = format!(
"{origin}/.well-known/oauth-authorization-server/{}",
profile.as_str()
);
let resp = http
.get(&endpoint)
.purpose(HttpPurpose::OAuthDiscovery)
.timeout(AUTH_TIMEOUT)
.send()
.await
.map_err(|e| Error::other(format!("discover: {e}")))?;
if !resp.status().is_success() {
return Err(Error::other(format!("discover: HTTP {}", resp.status())));
}
let meta: ServerMetadata = resp
.json()
.await
.map_err(|_| Error::other("discover: decode failed"))?;
if meta.token_endpoint.is_empty() || meta.authorization_endpoint.is_empty() {
return Err(Error::other(
"discover: metadata missing required endpoints",
));
}
Ok(meta)
}
pub async fn discover_with_transport(
http: &HttpClient,
server_url: &str,
) -> Result<ServerMetadata> {
discover_with_profile_with_transport(http, server_url, OAuthMetadataProfile::Desktop).await
}
pub async fn discover_web_oauth_metadata_with_transport(
http: &HttpClient,
server_url: &str,
) -> Result<ServerMetadata> {
discover_with_profile_with_transport(http, server_url, OAuthMetadataProfile::Web).await
}
pub async fn register_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
app_name: &str,
) -> Result<ClientRegistration> {
let body = serde_json::json!({
"client_name": app_name,
"token_endpoint_auth_method": "none",
"grant_types": ["authorization_code", "refresh_token"],
"redirect_uris": ["http://127.0.0.1/callback"],
"response_types": ["code"],
});
post_register(http, &meta.registration_endpoint, body).await
}
#[derive(Debug, Clone)]
pub struct RegisterWebOAuthClientOptions {
pub client_name: String,
pub redirect_uris: Vec<String>,
pub scopes: Option<Vec<String>>,
}
pub async fn register_web_oauth_client_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
opts: &RegisterWebOAuthClientOptions,
) -> Result<ClientRegistration> {
let mut body = serde_json::json!({
"client_name": opts.client_name,
"token_endpoint_auth_method": "none",
"grant_types": ["authorization_code", "refresh_token"],
"redirect_uris": opts.redirect_uris,
"response_types": ["code"],
});
if let Some(scopes) = &opts.scopes {
body["scope"] = serde_json::Value::String(scopes.join(" "));
}
post_register(http, &meta.registration_endpoint, body).await
}
async fn post_register(
http: &HttpClient,
endpoint: &str,
body: serde_json::Value,
) -> Result<ClientRegistration> {
let resp = http
.post(endpoint)
.purpose(HttpPurpose::OAuthRegistration)
.timeout(AUTH_TIMEOUT)
.json(&body)
.send()
.await
.map_err(|e| Error::other(format!("register: {e}")))?;
let status = resp.status().as_u16();
if status != 200 && status != 201 {
return Err(Error::other(format!("register: HTTP {status}")));
}
resp.json()
.await
.map_err(|_| Error::other("register: decode failed"))
}
fn random_base64url_32() -> String {
use rand::RngCore;
let mut b = [0u8; 32];
rand::rngs::OsRng.fill_bytes(&mut b);
base64url_no_pad(&b)
}
pub fn generate_code_verifier() -> String {
random_base64url_32()
}
pub fn generate_state() -> String {
random_base64url_32()
}
#[cfg(any(feature = "desktop-loopback", test))]
fn callback_state_failure(states: &[String], want: &str) -> Option<&'static str> {
match states {
[] => Some("callback missing state"),
[only] if only == want => None,
[_] => Some("callback state does not match pending state"),
_ => Some("callback carried multiple state values"),
}
}
pub fn code_challenge(verifier: &str) -> String {
let digest = Sha256::digest(verifier.as_bytes());
base64url_no_pad(&digest)
}
fn base64url_no_pad(b: &[u8]) -> String {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine as _;
URL_SAFE_NO_PAD.encode(b)
}
pub const EVENT_AUTH_URL: &str = "auth_url";
pub const EVENT_COMPLETE: &str = "complete";
pub const EVENT_ERROR: &str = "error";
pub const ERR_DISCOVERY: &str = "discovery_failed";
pub const ERR_REGISTRATION: &str = "registration_failed";
pub const ERR_BROWSER_OPEN: &str = "browser_open_failed";
pub const ERR_AUTH_DENIED: &str = "auth_denied";
pub const ERR_TIMEOUT: &str = "auth_timeout";
pub const ERR_TOKEN_EXCHANGE: &str = "token_exchange_failed";
pub const ERR_SSL_PROXY: &str = "ssl_proxy_detected";
pub const ERR_STATE_MISMATCH: &str = "state_mismatch";
#[derive(Debug, Clone, Default)]
pub struct LoginEvent {
pub r#type: String,
pub url: Option<String>,
pub error: Option<String>,
pub err_code: Option<String>,
}
impl LoginEvent {
pub fn auth_url(url: impl Into<String>) -> Self {
Self {
r#type: EVENT_AUTH_URL.to_string(),
url: Some(url.into()),
..Default::default()
}
}
pub fn complete() -> Self {
Self {
r#type: EVENT_COMPLETE.to_string(),
..Default::default()
}
}
pub fn error(code: impl Into<String>, error: impl Into<String>) -> Self {
Self {
r#type: EVENT_ERROR.to_string(),
err_code: Some(code.into()),
error: Some(error.into()),
..Default::default()
}
}
}
#[derive(Debug, Clone, Default)]
pub struct LoginOptions {
pub skip_browser: bool,
pub login_hint: Option<String>,
pub login_method: Option<String>,
pub org_uuid: Option<String>,
pub expires_in: Option<i64>,
pub success_redirect_url: Option<String>,
}
pub async fn exchange_code_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
client_id: &str,
code: &str,
redirect_uri: &str,
code_verifier: &str,
) -> Result<TokenResponse> {
let params = [
("grant_type", "authorization_code"),
("client_id", client_id),
("code", code),
("redirect_uri", redirect_uri),
("code_verifier", code_verifier),
];
post_token(http, &meta.token_endpoint, ¶ms).await
}
pub async fn exchange_code_with_expiry_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
client_id: &str,
code: &str,
redirect_uri: &str,
code_verifier: &str,
expires_in: i64,
) -> Result<TokenResponse> {
let expires_in_str = expires_in.to_string();
let params = [
("grant_type", "authorization_code"),
("client_id", client_id),
("code", code),
("redirect_uri", redirect_uri),
("code_verifier", code_verifier),
("expires_in", expires_in_str.as_str()),
];
post_token(http, &meta.token_endpoint, ¶ms).await
}
pub async fn refresh_token_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
client_id: &str,
refresh_token_value: &str,
) -> Result<TokenResponse> {
let params = [
("grant_type", "refresh_token"),
("client_id", client_id),
("refresh_token", refresh_token_value),
];
post_token(http, &meta.token_endpoint, ¶ms).await
}
pub async fn revoke_token_with_transport(
http: &HttpClient,
meta: &ServerMetadata,
token: &str,
) -> Result<()> {
if meta.revocation_endpoint.is_empty() {
return Ok(());
}
let params = [("token", token)];
http.post(&meta.revocation_endpoint)
.purpose(HttpPurpose::OAuthRevocation)
.timeout(AUTH_TIMEOUT)
.form(¶ms)
.send()
.await
.map_err(|e| Error::other(format!("revoke: {e}")))?;
Ok(())
}
async fn post_token(
http: &HttpClient,
endpoint: &str,
params: &[(&str, &str)],
) -> Result<TokenResponse> {
let resp = http
.post(endpoint)
.purpose(HttpPurpose::OAuthToken)
.timeout(AUTH_TIMEOUT)
.form(params)
.send()
.await
.map_err(|e| Error::other(format!("token request: {e}")))?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let (oauth_error, error_description) = match resp.json::<serde_json::Value>().await {
Ok(body) => (
body.get("error")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string(),
body.get("error_description")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string(),
),
Err(_) => (String::new(), String::new()),
};
return Err(Error::OAuthTokenEndpoint(OAuthTokenEndpointError {
status,
oauth_error,
error_description,
}));
}
resp.json()
.await
.map_err(|_| Error::other("token: decode failed"))
}
pub fn new_token_set(resp: &TokenResponse, client_id: &str, server_url: &str) -> TokenSet {
let mut expires_in = resp.expires_in;
if expires_in < 60 {
expires_in = 60;
}
let expires_at = (Utc::now() + chrono::Duration::seconds(expires_in)).to_rfc3339_opts(
chrono::SecondsFormat::Millis,
true, );
TokenSet {
access_token: resp.access_token.clone(),
refresh_token: resp.refresh_token.clone().unwrap_or_default(),
expires_at,
scope: resp.scope.clone().unwrap_or_default(),
client_id: client_id.to_string(),
server_url: server_url.to_string(),
}
}
#[derive(Debug, Clone)]
pub struct WebAuthorizationRequest {
pub auth_url: String,
pub state: String,
pub verifier: String,
pub client_id: String,
pub redirect_uri: String,
pub server_url: String,
pub created_at: i64,
}
#[derive(Debug, Clone)]
pub struct CreateWebAuthorizationRequestOptions {
pub client_id: String,
pub redirect_uri: String,
pub scopes: Vec<String>,
pub server_url: String,
pub login_hint: Option<String>,
}
pub fn create_web_authorization_request(
meta: &ServerMetadata,
opts: &CreateWebAuthorizationRequestOptions,
) -> Result<WebAuthorizationRequest> {
let verifier = generate_code_verifier();
let challenge = code_challenge(&verifier);
let state = generate_state();
let mut auth_url = url::Url::parse(&meta.authorization_endpoint).map_err(|e| {
Error::other(format!(
"createWebAuthorizationRequest: invalid auth endpoint: {e}"
))
})?;
{
let mut q = auth_url.query_pairs_mut();
q.append_pair("response_type", "code");
q.append_pair("client_id", &opts.client_id);
q.append_pair("redirect_uri", &opts.redirect_uri);
q.append_pair("code_challenge", &challenge);
q.append_pair("code_challenge_method", "S256");
q.append_pair("state", &state);
q.append_pair("scope", &opts.scopes.join(" "));
if let Some(hint) = &opts.login_hint {
q.append_pair("login_hint", hint);
}
}
Ok(WebAuthorizationRequest {
auth_url: auth_url.to_string(),
state,
verifier,
client_id: opts.client_id.clone(),
redirect_uri: opts.redirect_uri.clone(),
server_url: opts.server_url.clone(),
created_at: Utc::now().timestamp_millis(),
})
}
#[derive(Debug, Clone)]
pub struct WebAuthorizationPending {
pub state: String,
pub verifier: String,
pub client_id: String,
pub redirect_uri: String,
pub server_url: String,
}
#[derive(Debug, Clone)]
pub struct WebAuthorizationCallbackParams {
pub code: String,
pub state: String,
}
pub async fn complete_web_authorization_request_with_transport(
http: &HttpClient,
pending: &WebAuthorizationPending,
params: &WebAuthorizationCallbackParams,
) -> Result<TokenSet> {
if params.code.is_empty() {
return Err(Error::other(
"completeWebAuthorizationRequest: missing authorization code",
));
}
if params.state != pending.state {
return Err(Error::other(format!(
"completeWebAuthorizationRequest: {ERR_STATE_MISMATCH}: callback state does not match pending state (possible CSRF)"
)));
}
let meta = discover_web_oauth_metadata_with_transport(http, &pending.server_url).await?;
let resp = exchange_code_with_transport(
http,
&meta,
&pending.client_id,
¶ms.code,
&pending.redirect_uri,
&pending.verifier,
)
.await?;
Ok(new_token_set(
&resp,
&pending.client_id,
&pending.server_url,
))
}
#[derive(Debug, Clone)]
pub struct AuthorizeResult {
pub code: String,
pub redirect_uri: String,
}
pub fn build_desktop_authorization_url(
meta: &ServerMetadata,
client_id: &str,
redirect_uri: &str,
challenge: &str,
state: &str,
scopes: &[String],
opts: &LoginOptions,
) -> Result<String> {
let mut auth_url = url::Url::parse(&meta.authorization_endpoint)
.map_err(|e| Error::other(format!("authorize: invalid auth endpoint: {e}")))?;
{
let mut q = auth_url.query_pairs_mut();
q.append_pair("client_id", client_id);
q.append_pair("redirect_uri", redirect_uri);
q.append_pair("response_type", "code");
q.append_pair("code_challenge", challenge);
q.append_pair("code_challenge_method", "S256");
q.append_pair("state", state);
if !scopes.is_empty() {
q.append_pair("scope", &scopes.join(" "));
}
if let Some(hint) = &opts.login_hint {
q.append_pair("login_hint", hint);
}
if let Some(method) = &opts.login_method {
q.append_pair("login_method", method);
}
if let Some(org) = &opts.org_uuid {
q.append_pair("orgUUID", org);
}
}
Ok(auth_url.to_string())
}
pub fn resolve_success_redirect(raw: Option<&str>) -> Option<String> {
let raw = raw?;
let u = url::Url::parse(raw).ok()?;
match u.scheme() {
"http" | "https" => Some(u.to_string()),
_ => None,
}
}
#[cfg(feature = "desktop-loopback")]
pub use loopback::authorize;
#[cfg(feature = "desktop-loopback")]
mod loopback {
use super::*;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::mpsc;
const MAX_REQUEST_HEAD: usize = 8192;
const PER_CONN_READ_BUDGET: Duration = Duration::from_secs(10);
fn html_escape(s: &str) -> String {
s.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}
#[allow(clippy::too_many_arguments)]
pub async fn authorize(
meta: &ServerMetadata,
client_id: &str,
scopes: &[String],
opts: &LoginOptions,
handler: Option<&(dyn Fn(LoginEvent) + Send + Sync)>,
signal: Option<tokio_util::sync::CancellationToken>,
) -> Result<(AuthorizeResult, String)> {
let emit = |e: LoginEvent| {
if let Some(h) = handler {
h(e);
}
};
let verifier = generate_code_verifier();
let challenge = code_challenge(&verifier);
let state = generate_state();
let listener = TcpListener::bind("127.0.0.1:0")
.await
.map_err(|e| Error::other(format!("authorize: bind loopback: {e}")))?;
let port = listener
.local_addr()
.map_err(|e| Error::other(format!("authorize: local_addr: {e}")))?
.port();
let redirect_uri = format!("http://127.0.0.1:{port}/callback");
let auth_url = build_desktop_authorization_url(
meta,
client_id,
&redirect_uri,
&challenge,
&state,
scopes,
opts,
)?;
emit(LoginEvent::auth_url(auth_url.clone()));
let success_redirect = resolve_success_redirect(opts.success_redirect_url.as_deref());
let cancel = signal.unwrap_or_default();
let (tx, mut rx) = mpsc::channel::<Result<String>>(1);
let outcome: Result<String> = loop {
tokio::select! {
settled = rx.recv() => {
break settled.unwrap_or_else(|| Err(Error::other("authorization timed out")));
}
accepted = listener.accept() => match accepted {
Ok((stream, _)) => {
tokio::spawn(handle_connection(
stream,
state.clone(),
success_redirect.clone(),
tx.clone(),
));
}
Err(e) => break Err(Error::other(format!("authorize: accept: {e}"))),
},
_ = cancel.cancelled() => break Err(Error::other("authorization timed out")),
}
};
drop(listener);
match outcome {
Ok(c) => Ok((
AuthorizeResult {
code: c,
redirect_uri,
},
verifier,
)),
Err(e) => {
let msg = e.to_string();
let code = if msg.contains(ERR_STATE_MISMATCH) {
ERR_STATE_MISMATCH
} else if msg.contains("denied") {
ERR_AUTH_DENIED
} else if msg.contains("timed out") {
ERR_TIMEOUT
} else {
ERR_TOKEN_EXCHANGE
};
emit(LoginEvent::error(code, msg));
Err(e)
}
}
}
async fn handle_connection(
mut stream: TcpStream,
state: String,
success_redirect: Option<String>,
tx: mpsc::Sender<Result<String>>,
) {
let Some(head) = read_request_head(&mut stream).await else {
return;
};
let path = head.split_whitespace().nth(1).unwrap_or("/").to_string();
let full = format!("http://127.0.0.1{path}");
let Ok(parsed) = url::Url::parse(&full) else {
write_http(&mut stream, 400, "text/plain", "").await;
return;
};
if parsed.path() != "/callback" {
write_http(&mut stream, 404, "text/plain", "").await;
return;
}
let mut code: Option<String> = None;
let mut states: Vec<String> = Vec::new();
let mut err_desc = String::new();
let mut err_code = String::new();
for (k, v) in parsed.query_pairs() {
match k.as_ref() {
"code" => code = Some(v.to_string()),
"state" => states.push(v.to_string()),
"error_description" => err_desc = v.to_string(),
"error" => err_code = v.to_string(),
_ => {}
}
}
if let Some(reason) = callback_state_failure(&states, &state) {
write_http(
&mut stream,
200,
"text/html; charset=utf-8",
"<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>授权失败</title></head>\
<body style=\"font-family:system-ui,sans-serif;text-align:center;padding:60px 20px\">\
<h2>授权失败</h2><p>回调校验未通过, 已中止登录。</p>\
<p style=\"color:#888;font-size:14px\">可以关闭此窗口。</p></body></html>",
)
.await;
let _ = tx.try_send(Err(Error::other(format!(
"authorize: {ERR_STATE_MISMATCH}: {reason} (possible CSRF)"
))));
return;
}
match code {
Some(c) => {
if let Some(redir) = &success_redirect {
let resp = format!(
"HTTP/1.1 302 Found\r\nLocation: {redir}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
let _ = stream.write_all(resp.as_bytes()).await;
let _ = stream.shutdown().await;
} else {
let html = "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>授权成功</title></head>\
<body style=\"font-family:system-ui,sans-serif;text-align:center;padding:60px 20px\">\
<h2>授权成功</h2><p>已完成身份认证, 请返回应用继续使用。</p>\
<p style=\"color:#888;font-size:14px\">此窗口将在 3 秒后自动关闭…</p>\
<script>setTimeout(function(){window.close()},3000)</script></body></html>";
write_http(&mut stream, 200, "text/html; charset=utf-8", html).await;
}
let _ = tx.try_send(Ok(c));
}
None => {
let msg = if !err_desc.is_empty() {
err_desc
} else {
err_code
};
let html = format!(
"<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>授权失败</title></head>\
<body style=\"font-family:system-ui,sans-serif;text-align:center;padding:60px 20px\">\
<h2>授权失败</h2><p>{}</p>\
<p style=\"color:#888;font-size:14px\">可以关闭此窗口。</p></body></html>",
html_escape(&msg)
);
write_http(&mut stream, 200, "text/html; charset=utf-8", &html).await;
let _ = tx.try_send(Err(Error::other(format!("authorization denied: {msg}"))));
}
}
}
async fn read_request_head(stream: &mut TcpStream) -> Option<String> {
let fut = async {
let mut buf: Vec<u8> = Vec::with_capacity(1024);
let mut chunk = [0u8; 1024];
loop {
let n = stream.read(&mut chunk).await.ok()?;
if n == 0 {
break;
}
buf.extend_from_slice(&chunk[..n]);
if buf.windows(4).any(|w| w == b"\r\n\r\n") {
break;
}
if buf.len() >= MAX_REQUEST_HEAD {
return None;
}
}
if buf.is_empty() {
None
} else {
Some(String::from_utf8_lossy(&buf).into_owned())
}
};
tokio::time::timeout(PER_CONN_READ_BUDGET, fut)
.await
.ok()
.flatten()
}
async fn write_http(stream: &mut TcpStream, status: u16, content_type: &str, body: &str) {
let reason = match status {
200 => "OK",
400 => "Bad Request",
404 => "Not Found",
_ => "OK",
};
let resp = format!(
"HTTP/1.1 {status} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(resp.as_bytes()).await;
let _ = stream.shutdown().await;
}
}
#[cfg(feature = "native-http")]
pub async fn discover_with_profile(
http: &reqwest::Client,
server_url: &str,
profile: OAuthMetadataProfile,
) -> Result<ServerMetadata> {
discover_with_profile_with_transport(&HttpClient::legacy(http.clone()), server_url, profile)
.await
}
#[cfg(feature = "native-http")]
pub async fn discover_web_oauth_metadata(
http: &reqwest::Client,
server_url: &str,
) -> Result<ServerMetadata> {
discover_web_oauth_metadata_with_transport(&HttpClient::legacy(http.clone()), server_url).await
}
#[cfg(feature = "native-http")]
pub async fn register(
http: &reqwest::Client,
meta: &ServerMetadata,
app_name: &str,
) -> Result<ClientRegistration> {
register_with_transport(&HttpClient::legacy(http.clone()), meta, app_name).await
}
#[cfg(feature = "native-http")]
pub async fn register_web_oauth_client(
http: &reqwest::Client,
meta: &ServerMetadata,
opts: &RegisterWebOAuthClientOptions,
) -> Result<ClientRegistration> {
register_web_oauth_client_with_transport(&HttpClient::legacy(http.clone()), meta, opts).await
}
#[cfg(feature = "native-http")]
pub async fn exchange_code(
http: &reqwest::Client,
meta: &ServerMetadata,
client_id: &str,
code: &str,
redirect_uri: &str,
code_verifier: &str,
) -> Result<TokenResponse> {
exchange_code_with_transport(
&HttpClient::legacy(http.clone()),
meta,
client_id,
code,
redirect_uri,
code_verifier,
)
.await
}
#[cfg(feature = "native-http")]
pub async fn exchange_code_with_expiry(
http: &reqwest::Client,
meta: &ServerMetadata,
client_id: &str,
code: &str,
redirect_uri: &str,
code_verifier: &str,
expires_in: i64,
) -> Result<TokenResponse> {
exchange_code_with_expiry_with_transport(
&HttpClient::legacy(http.clone()),
meta,
client_id,
code,
redirect_uri,
code_verifier,
expires_in,
)
.await
}
#[cfg(feature = "native-http")]
pub async fn refresh_token(
http: &reqwest::Client,
meta: &ServerMetadata,
client_id: &str,
refresh_token_value: &str,
) -> Result<TokenResponse> {
refresh_token_with_transport(
&HttpClient::legacy(http.clone()),
meta,
client_id,
refresh_token_value,
)
.await
}
#[cfg(feature = "native-http")]
pub async fn revoke_token(
http: &reqwest::Client,
meta: &ServerMetadata,
token: &str,
) -> Result<()> {
revoke_token_with_transport(&HttpClient::legacy(http.clone()), meta, token).await
}
#[cfg(feature = "native-http")]
pub async fn complete_web_authorization_request(
http: &reqwest::Client,
pending: &WebAuthorizationPending,
params: &WebAuthorizationCallbackParams,
) -> Result<TokenSet> {
complete_web_authorization_request_with_transport(
&HttpClient::legacy(http.clone()),
pending,
params,
)
.await
}
impl std::fmt::Debug for OAuthTokenEndpointError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("OAuthTokenEndpointError")
.field("status", &self.status)
.finish_non_exhaustive()
}
}
#[cfg(feature = "native-http")]
pub async fn discover(http: &reqwest::Client, server_url: &str) -> Result<ServerMetadata> {
discover_with_transport(&HttpClient::legacy(http.clone()), server_url).await
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pkce_challenge_matches_rfc7636_vector() {
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let challenge = code_challenge(verifier);
assert_eq!(challenge, "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM");
}
#[test]
fn verifier_and_state_are_base64url_43_chars() {
let v = generate_code_verifier();
let s = generate_state();
assert_eq!(v.len(), 43);
assert_eq!(s.len(), 43);
assert!(!v.contains('+') && !v.contains('/') && !v.contains('='));
assert_ne!(v, s); }
#[test]
fn new_token_set_floors_short_expiry_to_60s() {
let resp = TokenResponse {
access_token: "at".into(),
token_type: "Bearer".into(),
expires_in: 0, refresh_token: Some("rt".into()),
scope: Some("ai".into()),
};
let ts = new_token_set(&resp, "cid", "https://acosmi.com");
assert_eq!(ts.client_id, "cid");
assert_eq!(ts.refresh_token, "rt");
let parsed = chrono::DateTime::parse_from_rfc3339(&ts.expires_at).unwrap();
assert!(parsed > Utc::now());
assert!(ts.expires_at.ends_with('Z'));
}
#[test]
fn new_token_set_missing_refresh_and_scope_default_empty() {
let resp = TokenResponse {
access_token: "at".into(),
token_type: "Bearer".into(),
expires_in: 3600,
refresh_token: None,
scope: None,
};
let ts = new_token_set(&resp, "cid", "https://acosmi.com");
assert_eq!(ts.refresh_token, "");
assert_eq!(ts.scope, "");
}
#[test]
fn resolve_success_redirect_rejects_non_http() {
assert!(resolve_success_redirect(None).is_none());
assert!(resolve_success_redirect(Some("javascript:alert(1)")).is_none());
assert!(resolve_success_redirect(Some("data:text/html,x")).is_none());
assert!(resolve_success_redirect(Some("not a url")).is_none());
assert!(resolve_success_redirect(Some("https://acosmi.com/ok")).is_some());
assert!(resolve_success_redirect(Some("http://127.0.0.1/cb")).is_some());
}
#[test]
fn is_invalid_grant_detects_oauth_error() {
let e = Error::OAuthTokenEndpoint(OAuthTokenEndpointError {
status: 400,
oauth_error: "invalid_grant".into(),
error_description: "refresh token not found".into(),
});
assert!(is_invalid_grant_error(&e));
let other = Error::other("nope");
assert!(!is_invalid_grant_error(&other));
}
#[test]
fn build_desktop_authorization_url_has_pkce_params() {
let meta = ServerMetadata {
issuer: "https://acosmi.com".into(),
authorization_endpoint: "https://acosmi.com/oauth/authorize".into(),
token_endpoint: "https://acosmi.com/oauth/token".into(),
revocation_endpoint: String::new(),
registration_endpoint: "https://acosmi.com/oauth/register".into(),
scopes_supported: vec![],
};
let opts = LoginOptions {
login_hint: Some("a@b.com".into()),
org_uuid: Some("org1".into()),
..Default::default()
};
let url = build_desktop_authorization_url(
&meta,
"cid",
"http://127.0.0.1:1234/callback",
"CHAL",
"STATE123",
&["ai".to_string(), "skills".to_string()],
&opts,
)
.unwrap();
assert!(url.contains("code_challenge=CHAL"));
assert!(url.contains("code_challenge_method=S256"));
assert!(url.contains("client_id=cid"));
assert!(url.contains("scope=ai+skills"));
assert!(url.contains("login_hint=a%40b.com"));
assert!(url.contains("orgUUID=org1"));
assert!(url.contains("state=STATE123"));
}
#[test]
fn generate_state_is_random_and_url_safe() {
let a = generate_state();
let b = generate_state();
assert_ne!(a, b, "state 必须每次不同, 否则起不到 CSRF 防护作用");
assert_eq!(a.len(), 43);
assert!(a
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'));
}
#[test]
fn callback_state_failure_matrix() {
let want = "S-correct";
let s = |v: &str| v.to_string();
assert_eq!(
callback_state_failure(&[s(want)], want),
None,
"唯一且相等 → 放行"
);
assert_eq!(
callback_state_failure(&[], want),
Some("callback missing state"),
"缺失 → 拒绝 (OAuth error 回调不带 state 同样走此路, 不得结算成 auth_denied)"
);
assert_eq!(
callback_state_failure(&[s("S-wrong")], want),
Some("callback state does not match pending state")
);
assert_eq!(
callback_state_failure(&[s(want), s("S-wrong")], want),
Some("callback carried multiple state values"),
"首值正确也不放行 —— 修复前循环取末值, 攻击者可用 ?state=<猜>&state=<junk> 蒙混"
);
assert_eq!(
callback_state_failure(&[s(want), s(want)], want),
Some("callback carried multiple state values"),
"重复的正确值也不是'恰好一个'"
);
}
}