use crate::{
AuthenticatedUser, Error, MwOAuthClient, PendingOAuthFlow, SessionStore as CoreSessionStore,
UserProfile,
};
use actix_session::config::{CookieContentSecurity, PersistentSession};
use actix_session::storage::CookieSessionStore;
use actix_session::{Session, SessionMiddleware};
use actix_web::cookie::{Key, SameSite, time::Duration as CookieDuration};
use actix_web::dev::Payload;
use actix_web::error::ErrorUnauthorized;
use actix_web::{Error as ActixError, FromRequest, HttpResponse, Responder, web};
use serde::Deserialize;
use std::future::Future;
use std::pin::Pin;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
const AUTH_SESSION_KEY: &str = "mwoauth_auth";
const FLOW_SESSION_KEY: &str = "mwoauth_flow";
#[derive(Clone, Debug)]
pub struct ActixOAuthState {
client: MwOAuthClient,
}
impl ActixOAuthState {
pub fn new(client: MwOAuthClient) -> Self {
Self { client }
}
pub fn client(&self) -> &MwOAuthClient {
&self.client
}
}
#[derive(Clone, Debug)]
pub struct CookieConfig {
pub name: String,
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 {
name: "mwoauth".to_owned(),
path: "/".to_owned(),
domain: None,
secure: true,
http_only: true,
same_site: SameSite::Lax,
max_age: None,
}
}
}
pub fn cookie_session_middleware(
key: Key,
config: CookieConfig,
) -> SessionMiddleware<CookieSessionStore> {
let mut builder = SessionMiddleware::builder(CookieSessionStore::default(), key)
.cookie_name(config.name)
.cookie_path(config.path)
.cookie_domain(config.domain)
.cookie_secure(config.secure)
.cookie_http_only(config.http_only)
.cookie_same_site(config.same_site)
.cookie_content_security(CookieContentSecurity::Private);
if let Some(max_age) = config.max_age {
let seconds = i64::try_from(max_age.as_secs()).unwrap_or(i64::MAX);
builder = builder.session_lifecycle(
PersistentSession::default().session_ttl(CookieDuration::seconds(seconds)),
);
}
builder.build()
}
pub fn configure(config: &mut web::ServiceConfig) {
config
.route("/oauth/login", web::get().to(login))
.route("/oauth/callback", web::get().to(callback))
.route("/oauth/logout", web::get().to(logout));
#[cfg(feature = "legacy-callback")]
config.route("/auth", web::get().to(callback));
}
#[derive(Clone, Debug)]
pub struct ActixUser(AuthenticatedUser);
impl ActixUser {
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 FromRequest for ActixUser {
type Error = ActixError;
type Future = Pin<Box<dyn Future<Output = Result<Self, Self::Error>>>>;
fn from_request(request: &actix_web::HttpRequest, payload: &mut Payload) -> Self::Future {
let session = match Session::from_request(request, payload).into_inner() {
Ok(session) => session,
Err(error) => return Box::pin(async { Err(error) }),
};
let state = request.app_data::<web::Data<ActixOAuthState>>().cloned();
Box::pin(async move {
extract_user(&session, state.as_ref().map(|state| state.get_ref()), true)
.await
.map(Self)
})
}
}
#[derive(Clone, Debug)]
pub struct OptionalActixUser(pub Option<ActixUser>);
impl FromRequest for OptionalActixUser {
type Error = ActixError;
type Future = Pin<Box<dyn Future<Output = Result<Self, Self::Error>>>>;
fn from_request(request: &actix_web::HttpRequest, payload: &mut Payload) -> Self::Future {
let session = match Session::from_request(request, payload).into_inner() {
Ok(session) => session,
Err(_) => return Box::pin(async { Ok(Self(None)) }),
};
let state = request.app_data::<web::Data<ActixOAuthState>>().cloned();
Box::pin(async move {
match extract_user(&session, state.as_ref().map(|state| state.get_ref()), false).await {
Ok(user) => Ok(Self(Some(ActixUser(user)))),
Err(error)
if error.as_response_error().status_code()
== actix_web::http::StatusCode::UNAUTHORIZED =>
{
Ok(Self(None))
}
Err(error) => Err(error),
}
})
}
}
impl OptionalActixUser {
pub fn into_option(self) -> Option<ActixUser> {
self.0
}
pub fn as_ref(&self) -> Option<&ActixUser> {
self.0.as_ref()
}
}
async fn extract_user(
session: &Session,
state: Option<&ActixOAuthState>,
invalid_as_unauthorized: bool,
) -> Result<AuthenticatedUser, ActixError> {
let user = session
.get::<AuthenticatedUser>(AUTH_SESSION_KEY)
.map_err(|_| {
if invalid_as_unauthorized {
ErrorUnauthorized("invalid authentication session")
} else {
actix_web::error::ErrorInternalServerError("invalid authentication session")
}
})?
.ok_or_else(|| ErrorUnauthorized("authentication required"))?;
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
if now >= user.session_expires_at() {
return Err(ErrorUnauthorized("authentication session expired"));
}
if user.token_expires_at().is_some_and(|expiry| now >= expiry) {
if user.token().refresh_token().is_none() {
return Err(ErrorUnauthorized("authentication session expired"));
}
let state = state.ok_or_else(|| ErrorUnauthorized("OAuth client missing"))?;
let refreshed = state
.client
.refresh_authenticated_user(&user)
.await
.map_err(|_| actix_web::error::ErrorBadGateway("OAuth provider request failed"))?;
session
.insert(AUTH_SESSION_KEY, &refreshed)
.map_err(actix_web::error::ErrorInternalServerError)?;
return Ok(refreshed);
}
Ok(user)
}
#[derive(Deserialize)]
struct CallbackQuery {
code: Option<String>,
state: Option<String>,
error: Option<String>,
}
async fn login(state: web::Data<ActixOAuthState>, session: Session) -> impl Responder {
let mut session = ActixSession::new(session);
match state.client.begin_authorization(&mut session, &[]) {
Ok(authorization) => HttpResponse::SeeOther()
.append_header(("Location", authorization.url.as_str()))
.finish(),
Err(error) => error_response(error),
}
}
async fn callback(
state: web::Data<ActixOAuthState>,
session: Session,
query: web::Query<CallbackQuery>,
) -> impl Responder {
let mut session = ActixSession::new(session);
if let Some(provider_error) = &query.error {
let _ = session.clear_pending_flow();
return error_response(Error::AuthorizationDenied {
error: sanitize_provider_error(provider_error),
});
}
let (Some(code), Some(callback_state)) = (&query.code, &query.state) else {
let _ = session.clear_pending_flow();
return error_response(Error::MissingFlowState);
};
match state
.client
.complete_authorization(&mut session, code, callback_state)
.await
{
Ok(_) => {
session.session.renew();
HttpResponse::SeeOther()
.append_header(("Location", "/"))
.finish()
}
Err(error) => error_response(error),
}
}
async fn logout(session: Session) -> impl Responder {
session.purge();
HttpResponse::SeeOther()
.append_header(("Location", "/"))
.finish()
}
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
}
}
fn error_response(error: Error) -> HttpResponse {
let status = match error.kind() {
crate::ErrorKind::Callback => actix_web::http::StatusCode::BAD_REQUEST,
crate::ErrorKind::Network | crate::ErrorKind::Provider => {
actix_web::http::StatusCode::BAD_GATEWAY
}
crate::ErrorKind::Configuration | crate::ErrorKind::Session => {
actix_web::http::StatusCode::INTERNAL_SERVER_ERROR
}
crate::ErrorKind::Unauthenticated => actix_web::http::StatusCode::UNAUTHORIZED,
};
HttpResponse::build(status).body(browser_error_message(&error))
}
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",
}
}
struct ActixSession {
session: Session,
}
impl ActixSession {
fn new(session: Session) -> Self {
Self { session }
}
}
impl CoreSessionStore for ActixSession {
fn pending_flow(&self) -> Result<Option<PendingOAuthFlow>, Error> {
self.session
.get(FLOW_SESSION_KEY)
.map_err(|_| Error::Session)
}
fn set_pending_flow(&mut self, flow: PendingOAuthFlow) -> Result<(), Error> {
self.session
.insert(FLOW_SESSION_KEY, flow)
.map_err(|_| Error::Session)
}
fn take_pending_flow(&mut self) -> Result<Option<PendingOAuthFlow>, Error> {
let flow = self.pending_flow();
self.session.remove(FLOW_SESSION_KEY);
flow
}
fn authenticated_user(&self) -> Result<Option<AuthenticatedUser>, Error> {
self.session
.get(AUTH_SESSION_KEY)
.map_err(|_| Error::Session)
}
fn set_authenticated_user(&mut self, user: AuthenticatedUser) -> Result<(), Error> {
self.session
.insert(AUTH_SESSION_KEY, user)
.map_err(|_| Error::Session)
}
fn clear_authenticated_user(&mut self) -> Result<(), Error> {
self.session.remove(AUTH_SESSION_KEY);
Ok(())
}
fn clear_pending_flow(&mut self) -> Result<(), Error> {
self.session.remove(FLOW_SESSION_KEY);
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::MwOAuthConfig;
use actix_web::cookie::Cookie;
use actix_web::{App, http, test};
use std::io;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use url::Url;
async fn required(user: ActixUser) -> impl Responder {
HttpResponse::Ok().body(format!(
"{}:{}",
user.profile().username(),
user.oauth2_token()
))
}
async fn soft(user: OptionalActixUser) -> impl Responder {
match user.into_option() {
Some(_) => HttpResponse::Ok().body("authenticated"),
None => HttpResponse::Ok().body("anonymous"),
}
}
async fn option_soft(user: Option<ActixUser>) -> impl Responder {
if user.is_some() {
HttpResponse::Ok().body("authenticated")
} else {
HttpResponse::Ok().body("anonymous")
}
}
async fn seed_expired_token(session: Session) -> impl Responder {
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();
session
.insert(
AUTH_SESSION_KEY,
AuthenticatedUser::new(profile, token, now - 10),
)
.unwrap();
HttpResponse::Ok().finish()
}
#[actix_web::test]
async fn expired_access_token_is_refreshed_and_saved() {
let (base_url, server) = mock_refresh().await;
let service = test::init_service(
App::new()
.app_data(state(&base_url))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.route("/seed", web::get().to(seed_expired_token))
.route("/required", web::get().to(required)),
)
.await;
let seeded =
test::call_service(&service, test::TestRequest::get().uri("/seed").to_request()).await;
let initial_cookie = response_cookie(&seeded, "mwoauth");
let refreshed = test::call_service(
&service,
test::TestRequest::get()
.uri("/required")
.cookie(initial_cookie)
.to_request(),
)
.await;
assert_eq!(refreshed.status(), http::StatusCode::OK);
let updated_cookie = response_cookie(&refreshed, "mwoauth");
assert_eq!(test::read_body(refreshed).await, "Example:new-access");
let next = test::call_service(
&service,
test::TestRequest::get()
.uri("/required")
.cookie(updated_cookie)
.to_request(),
)
.await;
assert_eq!(test::read_body(next).await, "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)
}
fn state(base_url: &str) -> web::Data<ActixOAuthState> {
state_with_ttl(base_url, None)
}
fn state_with_ttl(base_url: &str, ttl: Option<Duration>) -> web::Data<ActixOAuthState> {
let config = MwOAuthConfig::confidential(
Url::parse(base_url).unwrap(),
"client-id",
"client-secret",
Url::parse("http://localhost/oauth/callback").unwrap(),
"actix-test/1.0",
)
.unwrap();
let mut client = MwOAuthClient::new(config).unwrap();
if let Some(ttl) = ttl {
client = client.with_flow_ttl(ttl).unwrap();
}
web::Data::new(ActixOAuthState::new(client))
}
fn test_cookie_config() -> CookieConfig {
CookieConfig {
secure: false,
..CookieConfig::default()
}
}
fn response_cookie(response: &actix_web::dev::ServiceResponse, name: &str) -> Cookie<'static> {
response
.response()
.cookies()
.find(|cookie| cookie.name() == name)
.unwrap()
.into_owned()
}
fn state_from(response: &actix_web::dev::ServiceResponse) -> String {
let location = Url::parse(
response
.headers()
.get(http::header::LOCATION)
.unwrap()
.to_str()
.unwrap(),
)
.unwrap();
location
.query_pairs()
.find(|(key, _)| key == "state")
.unwrap()
.1
.into_owned()
}
#[actix_web::test]
async fn login_redirect_uses_encrypted_secure_session_cookie() {
let service = test::init_service(
App::new()
.app_data(state("https://wiki.test/w/api.php"))
.wrap(cookie_session_middleware(
Key::generate(),
CookieConfig::default(),
))
.configure(configure),
)
.await;
let response = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::SEE_OTHER);
let location = response
.headers()
.get(http::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 cookie = response_cookie(&response, "mwoauth");
assert_eq!(cookie.secure(), Some(true));
assert_eq!(cookie.http_only(), Some(true));
assert_eq!(cookie.same_site(), Some(SameSite::Lax));
assert!(!cookie.value().contains("mwoauth_flow"));
}
#[actix_web::test]
async fn callback_success_authenticates_required_and_soft_guards() {
let (base_url, server) = mock_mediawiki().await;
let service = test::init_service(
App::new()
.app_data(state(&base_url))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure)
.route("/required", web::get().to(required))
.route("/soft", web::get().to(soft))
.route("/option-soft", web::get().to(option_soft)),
)
.await;
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let callback_state = state_from(&login);
let flow_cookie = response_cookie(&login, "mwoauth");
let callback = test::call_service(
&service,
test::TestRequest::get()
.uri(&format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(callback.status(), http::StatusCode::SEE_OTHER);
let auth_cookie = response_cookie(&callback, "mwoauth");
assert!(!auth_cookie.value().contains("access-token"));
let replay = test::call_service(
&service,
test::TestRequest::get()
.uri(&format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.cookie(auth_cookie.clone())
.to_request(),
)
.await;
assert_eq!(replay.status(), http::StatusCode::BAD_REQUEST);
let required_response = test::call_service(
&service,
test::TestRequest::get()
.uri("/required")
.cookie(auth_cookie.clone())
.to_request(),
)
.await;
assert_eq!(required_response.status(), http::StatusCode::OK);
assert_eq!(
test::read_body(required_response).await,
"Example:access-token"
);
let soft_response = test::call_service(
&service,
test::TestRequest::get()
.uri("/soft")
.cookie(auth_cookie.clone())
.to_request(),
)
.await;
assert_eq!(test::read_body(soft_response).await, "authenticated");
let option_response = test::call_service(
&service,
test::TestRequest::get()
.uri("/option-soft")
.cookie(auth_cookie)
.to_request(),
)
.await;
assert_eq!(test::read_body(option_response).await, "authenticated");
let logout = test::call_service(
&service,
test::TestRequest::get()
.uri("/oauth/logout")
.cookie(response_cookie(&callback, "mwoauth"))
.to_request(),
)
.await;
assert_eq!(logout.status(), http::StatusCode::SEE_OTHER);
let removal = response_cookie(&logout, "mwoauth");
let response = test::call_service(
&service,
test::TestRequest::get()
.uri("/required")
.cookie(removal)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
server.await.unwrap().unwrap();
}
#[actix_web::test]
async fn guards_reject_missing_and_tampered_sessions() {
let service = test::init_service(
App::new()
.app_data(state("https://wiki.test/w/api.php"))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.route("/required", web::get().to(required))
.route("/soft", web::get().to(soft))
.route("/option-soft", web::get().to(option_soft)),
)
.await;
let response = test::call_service(
&service,
test::TestRequest::get().uri("/required").to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
let response = test::call_service(
&service,
test::TestRequest::get()
.uri("/required")
.cookie(Cookie::new("mwoauth", "forged"))
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
let response =
test::call_service(&service, test::TestRequest::get().uri("/soft").to_request()).await;
assert_eq!(test::read_body(response).await, "anonymous");
let response = test::call_service(
&service,
test::TestRequest::get().uri("/option-soft").to_request(),
)
.await;
assert_eq!(test::read_body(response).await, "anonymous");
}
#[actix_web::test]
async fn provider_denial_and_state_mismatch_fail_safely() {
let service = test::init_service(
App::new()
.app_data(state("https://wiki.test/w/api.php"))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure),
)
.await;
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let flow_cookie = response_cookie(&login, "mwoauth");
let response = test::call_service(
&service,
test::TestRequest::get()
.uri("/oauth/callback?error=access_denied")
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
assert_eq!(
test::read_body(response).await,
"OAuth callback validation failed"
);
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let flow_cookie = response_cookie(&login, "mwoauth");
let response = test::call_service(
&service,
test::TestRequest::get()
.uri("/oauth/callback?code=test-code&state=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
let replay = test::call_service(
&service,
test::TestRequest::get()
.uri("/oauth/callback?code=test-code&state=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.to_request(),
)
.await;
assert_eq!(replay.status(), http::StatusCode::BAD_REQUEST);
}
#[actix_web::test]
async fn expired_callback_and_provider_failure_are_mapped() {
let service = test::init_service(
App::new()
.app_data(state_with_ttl(
"https://wiki.test/w/api.php",
Some(Duration::from_secs(1)),
))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure),
)
.await;
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let callback_state = state_from(&login);
let flow_cookie = response_cookie(&login, "mwoauth");
tokio::time::sleep(Duration::from_secs(1)).await;
let response = test::call_service(
&service,
test::TestRequest::get()
.uri(&format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
let (base_url, server) = mock_token_failure().await;
let service = test::init_service(
App::new()
.app_data(state(&base_url))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure),
)
.await;
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let callback_state = state_from(&login);
let flow_cookie = response_cookie(&login, "mwoauth");
let response = test::call_service(
&service,
test::TestRequest::get()
.uri(&format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::BAD_GATEWAY);
assert_eq!(
test::read_body(response).await,
"OAuth provider request failed"
);
server.await.unwrap().unwrap();
}
#[actix_web::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 service = test::init_service(
App::new()
.app_data(state(&format!("http://{address}/w/api.php")))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure),
)
.await;
let login = test::call_service(
&service,
test::TestRequest::get().uri("/oauth/login").to_request(),
)
.await;
let callback_state = state_from(&login);
let flow_cookie = response_cookie(&login, "mwoauth");
let response = test::call_service(
&service,
test::TestRequest::get()
.uri(&format!(
"/oauth/callback?code=test-code&state={callback_state}"
))
.cookie(flow_cookie)
.to_request(),
)
.await;
assert_eq!(response.status(), http::StatusCode::BAD_GATEWAY);
}
#[cfg(feature = "legacy-callback")]
#[actix_web::test]
async fn legacy_callback_route_is_registered() {
let service = test::init_service(
App::new()
.app_data(state("https://wiki.test/w/api.php"))
.wrap(cookie_session_middleware(
Key::generate(),
test_cookie_config(),
))
.configure(configure),
)
.await;
let response = test::call_service(
&service,
test::TestRequest::get()
.uri("/auth?error=access_denied")
.to_request(),
)
.await;
assert_eq!(response.status(), http::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)
}
}