use crate::{AuthenticatedUser, Error, MwOAuthClient, PendingOAuthFlow, SessionStore, UserProfile};
use axum::Router;
use axum::extract::{FromRef, FromRequestParts, OptionalFromRequestParts, Query, Request, State};
use axum::http::{StatusCode, request::Parts};
use axum::middleware::Next;
use axum::response::{IntoResponse, Redirect, Response};
use axum::routing::get;
use axum_extra::extract::cookie::{Cookie, PrivateCookieJar};
pub use axum_extra::extract::cookie::{Key, SameSite};
use serde::Deserialize;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
const AUTH_COOKIE_NAME: &str = "mwoauth_auth";
const FLOW_COOKIE_NAME: &str = "mwoauth_flow";
#[derive(Clone, Debug)]
pub struct CookieConfig {
pub path: String,
pub domain: Option<String>,
pub secure: bool,
pub http_only: bool,
pub same_site: SameSite,
pub max_age: Option<Duration>,
}
impl Default for CookieConfig {
fn default() -> Self {
Self {
path: "/".to_owned(),
domain: None,
secure: true,
http_only: true,
same_site: SameSite::Lax,
max_age: None,
}
}
}
#[derive(Clone, Debug)]
pub struct AxumOAuthState {
client: MwOAuthClient,
cookie_key: Key,
cookies: CookieConfig,
}
impl AxumOAuthState {
pub fn new(client: MwOAuthClient, cookie_key: Key) -> Self {
Self {
client,
cookie_key,
cookies: CookieConfig::default(),
}
}
pub fn with_cookie_config(mut self, cookies: CookieConfig) -> Self {
self.cookies = cookies;
self
}
pub fn client(&self) -> &MwOAuthClient {
&self.client
}
pub fn cookie_config(&self) -> &CookieConfig {
&self.cookies
}
}
impl FromRef<AxumOAuthState> for Key {
fn from_ref(state: &AxumOAuthState) -> Self {
state.cookie_key.clone()
}
}
impl FromRef<AxumOAuthState> for MwOAuthClient {
fn from_ref(state: &AxumOAuthState) -> Self {
state.client.clone()
}
}
pub fn routes<S>() -> Router<S>
where
S: Clone + Send + Sync + 'static,
AxumOAuthState: FromRef<S>,
Key: FromRef<S>,
{
let router = Router::new()
.route("/oauth/login", get(login))
.route("/oauth/callback", get(callback))
.route("/oauth/logout", get(logout));
#[cfg(feature = "legacy-callback")]
let router = router.route("/auth", get(callback));
router
}
pub fn oauth_router(state: AxumOAuthState) -> Router {
routes().with_state(state)
}
#[derive(Clone, Debug)]
pub struct AxumUser(AuthenticatedUser);
impl AxumUser {
pub fn profile(&self) -> &UserProfile {
self.0.profile()
}
pub fn oauth2_token(&self) -> &str {
self.0.token().access_token()
}
pub fn authenticated_user(&self) -> &AuthenticatedUser {
&self.0
}
}
impl<S> FromRequestParts<S> for AxumUser
where
S: Send + Sync,
AxumOAuthState: FromRef<S>,
Key: FromRef<S>,
{
type Rejection = StatusCode;
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
extract_user(parts, state)
.await
.ok_or(StatusCode::UNAUTHORIZED)
}
}
impl<S> OptionalFromRequestParts<S> for AxumUser
where
S: Send + Sync,
AxumOAuthState: FromRef<S>,
Key: FromRef<S>,
{
type Rejection = std::convert::Infallible;
async fn from_request_parts(
parts: &mut Parts,
state: &S,
) -> Result<Option<Self>, Self::Rejection> {
Ok(extract_user(parts, state).await)
}
}
async fn extract_user<S>(parts: &mut Parts, state: &S) -> Option<AxumUser>
where
S: Send + Sync,
AxumOAuthState: FromRef<S>,
Key: FromRef<S>,
{
if let Some(refreshed) = parts.extensions.get::<RefreshedUser>() {
return Some(AxumUser(refreshed.0.clone()));
}
let jar = PrivateCookieJar::from_request_parts(parts, state)
.await
.ok()?;
let session = AxumSession::new(jar, AxumOAuthState::from_ref(state).cookies);
session
.authenticated_user()
.ok()
.flatten()
.filter(|user| !is_expired(user))
.map(AxumUser)
}
#[derive(Clone)]
struct RefreshedUser(AuthenticatedUser);
pub async fn refresh_session(
State(state): State<AxumOAuthState>,
jar: PrivateCookieJar,
mut request: Request,
next: Next,
) -> Response {
if request.uri().path().starts_with("/oauth/") || request.uri().path() == "/auth" {
return next.run(request).await;
}
let mut session = AxumSession::new(jar, state.cookies);
let Ok(Some(user)) = session.authenticated_user() else {
return next.run(request).await;
};
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
if now >= user.session_expires_at() || !is_expired(&user) {
return next.run(request).await;
}
if user.token().refresh_token().is_none() {
return next.run(request).await;
}
match state.client.refresh_authenticated_user(&user).await {
Ok(refreshed) => {
if let Err(error) = session.set_authenticated_user(refreshed.clone()) {
return AxumError::with_jar(error, session.into_jar()).into_response();
}
request.extensions_mut().insert(RefreshedUser(refreshed));
(session.into_jar(), next.run(request).await).into_response()
}
Err(error) => AxumError::with_jar(error, session.into_jar()).into_response(),
}
}
fn is_expired(user: &AuthenticatedUser) -> bool {
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
now >= user.session_expires_at()
|| user
.token_expires_at()
.is_some_and(|expires_at| now >= expires_at)
}
#[derive(Deserialize)]
struct CallbackQuery {
code: Option<String>,
state: Option<String>,
error: Option<String>,
}
async fn login(
State(state): State<AxumOAuthState>,
jar: PrivateCookieJar,
) -> Result<(PrivateCookieJar, Redirect), AxumError> {
let mut session = AxumSession::new(jar, state.cookies);
let authorization = state.client.begin_authorization(&mut session, &[])?;
Ok((session.into_jar(), Redirect::to(authorization.url.as_str())))
}
async fn callback(
State(state): State<AxumOAuthState>,
jar: PrivateCookieJar,
Query(query): Query<CallbackQuery>,
) -> Result<(PrivateCookieJar, Redirect), AxumError> {
let mut session = AxumSession::new(jar, state.cookies);
if let Some(provider_error) = query.error {
session.clear_pending_flow()?;
return Err(AxumError::with_jar(
Error::AuthorizationDenied {
error: sanitize_provider_error(&provider_error),
},
session.into_jar(),
));
}
let (Some(code), Some(callback_state)) = (query.code, query.state) else {
session.clear_pending_flow()?;
return Err(AxumError::with_jar(
Error::MissingFlowState,
session.into_jar(),
));
};
if let Err(error) = state
.client
.complete_authorization(&mut session, &code, &callback_state)
.await
{
return Err(AxumError::with_jar(error, session.into_jar()));
}
Ok((session.into_jar(), Redirect::to("/")))
}
async fn logout(
State(state): State<AxumOAuthState>,
jar: PrivateCookieJar,
) -> (PrivateCookieJar, Redirect) {
let mut session = AxumSession::new(jar, state.cookies);
let _ = session.clear();
(session.into_jar(), Redirect::to("/"))
}
fn sanitize_provider_error(value: &str) -> String {
let value: String = value
.chars()
.filter(|character| character.is_ascii_alphanumeric() || matches!(character, '_' | '-'))
.take(64)
.collect();
if value.is_empty() {
"unknown_error".to_owned()
} else {
value
}
}
struct AxumSession {
jar: PrivateCookieJar,
cookies: CookieConfig,
}
impl AxumSession {
fn new(jar: PrivateCookieJar, cookies: CookieConfig) -> Self {
Self { jar, cookies }
}
fn into_jar(self) -> PrivateCookieJar {
self.jar
}
fn private_cookie<T: serde::de::DeserializeOwned>(
&self,
name: &str,
) -> Result<Option<T>, Error> {
self.jar
.get(name)
.map(|cookie| serde_json::from_str(cookie.value()).map_err(|_| Error::Session))
.transpose()
}
fn set_private_cookie<T: serde::Serialize>(
&mut self,
name: &'static str,
value: &T,
) -> Result<(), Error> {
let value = serde_json::to_string(value).map_err(|_| Error::Session)?;
let mut cookie = Cookie::build((name, value))
.path(self.cookies.path.clone())
.secure(self.cookies.secure)
.http_only(self.cookies.http_only)
.same_site(self.cookies.same_site)
.build();
if let Some(max_age) = self.cookies.max_age {
let seconds = i64::try_from(max_age.as_secs()).unwrap_or(i64::MAX);
cookie.set_max_age(time::Duration::seconds(seconds));
}
if let Some(domain) = &self.cookies.domain {
cookie.set_domain(domain.clone());
}
self.jar = self.jar.clone().add(cookie);
Ok(())
}
fn remove_private_cookie(&mut self, name: &'static str) {
let mut cookie = Cookie::build(name).path(self.cookies.path.clone()).build();
if let Some(domain) = &self.cookies.domain {
cookie.set_domain(domain.clone());
}
self.jar = self.jar.clone().remove(cookie);
}
}
impl SessionStore for AxumSession {
fn pending_flow(&self) -> Result<Option<PendingOAuthFlow>, Error> {
self.private_cookie(FLOW_COOKIE_NAME)
}
fn set_pending_flow(&mut self, flow: PendingOAuthFlow) -> Result<(), Error> {
self.set_private_cookie(FLOW_COOKIE_NAME, &flow)
}
fn take_pending_flow(&mut self) -> Result<Option<PendingOAuthFlow>, Error> {
let flow = self.pending_flow();
self.remove_private_cookie(FLOW_COOKIE_NAME);
flow
}
fn authenticated_user(&self) -> Result<Option<AuthenticatedUser>, Error> {
self.private_cookie(AUTH_COOKIE_NAME)
}
fn set_authenticated_user(&mut self, user: AuthenticatedUser) -> Result<(), Error> {
self.set_private_cookie(AUTH_COOKIE_NAME, &user)
}
fn clear_authenticated_user(&mut self) -> Result<(), Error> {
self.remove_private_cookie(AUTH_COOKIE_NAME);
Ok(())
}
fn clear_pending_flow(&mut self) -> Result<(), Error> {
self.remove_private_cookie(FLOW_COOKIE_NAME);
Ok(())
}
}
struct AxumError {
error: Error,
jar: Option<Box<PrivateCookieJar>>,
}
impl AxumError {
fn with_jar(error: Error, jar: PrivateCookieJar) -> Self {
Self {
error,
jar: Some(Box::new(jar)),
}
}
}
impl From<Error> for AxumError {
fn from(error: Error) -> Self {
Self { error, jar: None }
}
}
impl IntoResponse for AxumError {
fn into_response(self) -> Response {
let status = match self.error.kind() {
crate::ErrorKind::Callback => StatusCode::BAD_REQUEST,
crate::ErrorKind::Network | crate::ErrorKind::Provider => StatusCode::BAD_GATEWAY,
crate::ErrorKind::Configuration | crate::ErrorKind::Session => {
StatusCode::INTERNAL_SERVER_ERROR
}
crate::ErrorKind::Unauthenticated => StatusCode::UNAUTHORIZED,
};
let body = browser_error_message(&self.error);
match self.jar {
Some(jar) => (*jar, (status, body)).into_response(),
None => (status, body).into_response(),
}
}
}
fn browser_error_message(error: &Error) -> &'static str {
match error.kind() {
crate::ErrorKind::Callback => "OAuth callback validation failed",
crate::ErrorKind::Network | crate::ErrorKind::Provider => "OAuth provider request failed",
crate::ErrorKind::Configuration | crate::ErrorKind::Session => "Internal OAuth error",
crate::ErrorKind::Unauthenticated => "Authentication required",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::MwOAuthConfig;
use axum::body::{Body, to_bytes};
use axum::http::{Request, header};
use axum::middleware::from_extractor_with_state;
use std::io;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tower::ServiceExt;
use url::Url;
async fn required(user: AxumUser) -> String {
format!("{}:{}", user.profile().username(), user.oauth2_token())
}
async fn soft(user: Option<AxumUser>) -> &'static str {
if user.is_some() {
"authenticated"
} else {
"anonymous"
}
}
async fn protected() -> &'static str {
"protected"
}
async fn seed_expired_token(
State(state): State<AxumOAuthState>,
jar: PrivateCookieJar,
) -> PrivateCookieJar {
let token = serde_json::from_str(
r#"{"access_token":"old-access","refresh_token":"old-refresh","expires_in":1}"#,
)
.unwrap();
let profile = serde_json::from_str(
r#"{"sub":"42","username":"Example","blocked":false,"confirmed_email":true,"editcount":10,"email_verified":true,"registered":"2020-01-01T00:00:00Z"}"#,
)
.unwrap();
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs();
let mut session = AxumSession::new(jar, state.cookies);
session
.set_authenticated_user(AuthenticatedUser::new(profile, token, now - 10))
.unwrap();
session.into_jar()
}
fn state(base_url: &str) -> AxumOAuthState {
state_with_ttl(base_url, None)
}
fn state_with_ttl(base_url: &str, ttl: Option<Duration>) -> AxumOAuthState {
let config = MwOAuthConfig::confidential(
Url::parse(base_url).unwrap(),
"client-id",
"client-secret",
Url::parse("https://app.test/oauth/callback").unwrap(),
"axum-test/1.0",
)
.unwrap();
let mut client = MwOAuthClient::new(config).unwrap();
if let Some(ttl) = ttl {
client = client.with_flow_ttl(ttl).unwrap();
}
AxumOAuthState::new(client, Key::generate()).with_cookie_config(CookieConfig {
secure: false,
..CookieConfig::default()
})
}
fn app(state: AxumOAuthState) -> Router {
routes()
.route("/seed", get(seed_expired_token))
.route("/required", get(required))
.route("/soft", get(soft))
.route(
"/protected",
get(protected).route_layer(from_extractor_with_state::<AxumUser, _>(state.clone())),
)
.layer(axum::middleware::from_fn_with_state(
state.clone(),
refresh_session,
))
.with_state(state)
}
fn cookie_from(response: &Response, name: &str) -> String {
response
.headers()
.get_all(header::SET_COOKIE)
.iter()
.filter_map(|value| value.to_str().ok())
.find(|value| value.starts_with(&format!("{name}=")))
.and_then(|value| value.split(';').next())
.unwrap()
.to_owned()
}
fn state_from(response: &Response) -> String {
let location = Url::parse(
response
.headers()
.get(header::LOCATION)
.unwrap()
.to_str()
.unwrap(),
)
.unwrap();
location
.query_pairs()
.find(|(key, _)| key == "state")
.unwrap()
.1
.into_owned()
}
#[tokio::test]
async fn expired_access_token_is_refreshed_and_cookie_is_saved() {
let (base_url, server) = mock_refresh().await;
let app = app(state(&base_url));
let seeded = app
.clone()
.oneshot(Request::get("/seed").body(Body::empty()).unwrap())
.await
.unwrap();
let original_cookie = cookie_from(&seeded, AUTH_COOKIE_NAME);
let refreshed = app
.clone()
.oneshot(
Request::get("/required")
.header(header::COOKIE, original_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(refreshed.status(), StatusCode::OK);
let updated_cookie = cookie_from(&refreshed, AUTH_COOKIE_NAME);
assert_eq!(
to_bytes(refreshed.into_body(), usize::MAX).await.unwrap(),
"Example:new-access"
);
let next = app
.oneshot(
Request::get("/required")
.header(header::COOKIE, updated_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(
to_bytes(next.into_body(), usize::MAX).await.unwrap(),
"Example:new-access"
);
server.await.unwrap().unwrap();
}
async fn mock_refresh() -> (String, tokio::task::JoinHandle<io::Result<()>>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let responses = [
r#"{"access_token":"new-access","expires_in":3600}"#,
r#"{"sub":"42","username":"Example","blocked":false,"confirmed_email":true,"editcount":10,"email_verified":true,"registered":"2020-01-01T00:00:00Z"}"#,
];
for (index, body) in responses.into_iter().enumerate() {
let (mut stream, _) = listener.accept().await?;
let mut request = vec![0_u8; 8192];
let bytes = stream.read(&mut request).await?;
let request = String::from_utf8_lossy(&request[..bytes]);
if index == 0 {
assert!(request.contains("grant_type=refresh_token"));
assert!(request.contains("refresh_token=old-refresh"));
}
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await?;
}
Ok(())
});
(format!("http://{address}/w/api.php"), server)
}
#[tokio::test]
async fn login_redirect_sets_private_cookie_with_secure_defaults() {
let response = app(state("https://wiki.test/w/api.php"))
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::SEE_OTHER);
let location = response
.headers()
.get(header::LOCATION)
.unwrap()
.to_str()
.unwrap();
assert!(location.starts_with("https://wiki.test/w/rest.php/oauth2/authorize?"));
assert!(location.contains("code_challenge_method=S256"));
let set_cookie = response
.headers()
.get(header::SET_COOKIE)
.unwrap()
.to_str()
.unwrap();
assert!(set_cookie.starts_with(FLOW_COOKIE_NAME));
assert!(set_cookie.contains("HttpOnly"));
assert!(set_cookie.contains("SameSite=Lax"));
assert!(!set_cookie.contains('{'));
let production_state = AxumOAuthState::new(
MwOAuthClient::new(
MwOAuthConfig::confidential(
Url::parse("https://wiki.test/w/api.php").unwrap(),
"client-id",
"client-secret",
Url::parse("https://app.test/oauth/callback").unwrap(),
"axum-test/1.0",
)
.unwrap(),
)
.unwrap(),
Key::generate(),
);
let response = oauth_router(production_state)
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
assert!(
response
.headers()
.get(header::SET_COOKIE)
.unwrap()
.to_str()
.unwrap()
.contains("Secure")
);
}
#[tokio::test]
async fn callback_success_authenticates_required_soft_and_layered_routes() {
let (base_url, server) = mock_mediawiki().await;
let state = state(&base_url);
let app = app(state);
let login = app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let callback_state = state_from(&login);
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
let callback = app
.clone()
.oneshot(
Request::get(format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(callback.status(), StatusCode::SEE_OTHER);
let auth_cookie = cookie_from(&callback, AUTH_COOKIE_NAME);
assert!(!auth_cookie.contains('{'));
let replay = app
.clone()
.oneshot(
Request::get(format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.header(header::COOKIE, &auth_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(replay.status(), StatusCode::BAD_REQUEST);
for path in ["/required", "/protected"] {
let response = app
.clone()
.oneshot(
Request::get(path)
.header(header::COOKIE, &auth_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
}
let response = app
.clone()
.oneshot(
Request::get("/soft")
.header(header::COOKIE, &auth_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
"authenticated"
);
let logout = app
.clone()
.oneshot(
Request::get("/oauth/logout")
.header(header::COOKIE, auth_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(logout.status(), StatusCode::SEE_OTHER);
let removal = cookie_from(&logout, AUTH_COOKIE_NAME);
let response = app
.oneshot(
Request::get("/required")
.header(header::COOKIE, removal)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
server.await.unwrap().unwrap();
}
#[tokio::test]
async fn missing_invalid_and_soft_authentication_are_mapped_correctly() {
let app = app(state("https://wiki.test/w/api.php"));
assert_eq!(
app.clone()
.oneshot(Request::get("/required").body(Body::empty()).unwrap())
.await
.unwrap()
.status(),
StatusCode::UNAUTHORIZED
);
assert_eq!(
app.clone()
.oneshot(Request::get("/protected").body(Body::empty()).unwrap())
.await
.unwrap()
.status(),
StatusCode::UNAUTHORIZED
);
assert_eq!(
app.clone()
.oneshot(
Request::get("/required")
.header(header::COOKIE, "mwoauth_auth=forged")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap()
.status(),
StatusCode::UNAUTHORIZED
);
let response = app
.oneshot(Request::get("/soft").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
"anonymous"
);
}
#[tokio::test]
async fn provider_denial_is_safe_and_consumes_the_flow_cookie() {
let app = app(state("https://wiki.test/w/api.php"));
let login = app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
let response = app
.oneshot(
Request::get("/oauth/callback?error=access_denied")
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let body = to_bytes(response.into_body(), 1024).await.unwrap();
assert_eq!(body, "OAuth callback validation failed");
}
#[tokio::test]
async fn callback_state_failure_consumes_the_flow_cookie() {
let app = app(state("https://wiki.test/w/api.php"));
let login = app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
let response = app
.clone()
.oneshot(
Request::get("/oauth/callback?code=test-code&state=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let removal = response
.headers()
.get(header::SET_COOKIE)
.unwrap()
.to_str()
.unwrap();
assert!(removal.starts_with(FLOW_COOKIE_NAME));
assert!(removal.contains("Max-Age=0"));
let replay = app
.oneshot(
Request::get("/oauth/callback?code=test-code&state=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(replay.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn expired_callback_and_provider_failure_are_mapped() {
let oauth_state =
state_with_ttl("https://wiki.test/w/api.php", Some(Duration::from_secs(1)));
let test_app = app(oauth_state);
let login = test_app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let callback_state = state_from(&login);
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
tokio::time::sleep(Duration::from_secs(1)).await;
let response = test_app
.oneshot(
Request::get(format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let (base_url, server) = mock_token_failure().await;
let test_app = app(state(&base_url));
let login = test_app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let callback_state = state_from(&login);
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
let response = test_app
.oneshot(
Request::get(format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
"OAuth provider request failed"
);
server.await.unwrap().unwrap();
}
#[tokio::test]
async fn network_failure_returns_bad_gateway() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
drop(listener);
let app = app(state(&format!("http://{address}/w/api.php")));
let login = app
.clone()
.oneshot(Request::get("/oauth/login").body(Body::empty()).unwrap())
.await
.unwrap();
let callback_state = state_from(&login);
let flow_cookie = cookie_from(&login, FLOW_COOKIE_NAME);
let response = app
.oneshot(
Request::get(format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.header(header::COOKIE, flow_cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
}
#[cfg(feature = "legacy-callback")]
#[tokio::test]
async fn legacy_callback_route_is_registered() {
let response = app(state("https://wiki.test/w/api.php"))
.oneshot(
Request::get("/auth?error=access_denied")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
async fn mock_token_failure() -> (String, tokio::task::JoinHandle<io::Result<()>>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await?;
let mut request = vec![0_u8; 8192];
let _ = stream.read(&mut request).await?;
let body = "provider unavailable";
let response = format!(
"HTTP/1.1 503 Service Unavailable\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await?;
Ok(())
});
(format!("http://{address}/w/api.php"), server)
}
async fn mock_mediawiki() -> (String, tokio::task::JoinHandle<io::Result<()>>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let responses = [
r#"{"access_token":"access-token","refresh_token":"refresh-token","expires_in":3600,"token_type":"Bearer"}"#,
r#"{"sub":"42","username":"Example","blocked":false,"confirmed_email":true,"editcount":10,"email_verified":true,"grants":["basic"],"groups":["user"],"registered":"2020-01-01T00:00:00Z","rights":["read"]}"#,
];
for (index, body) in responses.into_iter().enumerate() {
let (mut stream, _) = listener.accept().await?;
let mut request = vec![0_u8; 8192];
let bytes_read = stream.read(&mut request).await?;
let request = String::from_utf8_lossy(&request[..bytes_read]);
if index == 0 {
assert!(request.starts_with("POST /w/rest.php/oauth2/access_token"));
assert!(request.contains("code=test-code"));
assert!(request.contains("code_verifier="));
} else {
assert!(request.starts_with("GET /w/rest.php/oauth2/resource/profile"));
assert!(
request
.to_ascii_lowercase()
.contains("authorization: bearer access-token")
);
}
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await?;
}
Ok(())
});
(format!("http://{address}/w/api.php"), server)
}
}