Skip to main content

tuwunel_api/router/
auth.rs

1pub(crate) mod admin;
2mod appservice;
3mod dispatch;
4#[cfg(feature = "jwt_login")]
5pub(crate) mod jwt;
6mod server;
7mod uiaa;
8
9use std::{any::TypeId, fmt::Debug, time::SystemTime};
10
11use axum::RequestPartsExt;
12use axum_extra::{
13	TypedHeader,
14	headers::{Authorization, authorization::Bearer},
15};
16use futures::{
17	FutureExt, TryFutureExt,
18	future::{select_ok, try_join},
19	pin_mut,
20};
21use ruma::{
22	CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId,
23	api::client::{
24		directory::get_public_rooms,
25		knock::knock_room,
26		membership::{
27			ban_user, invite_user, join_room_by_id, join_room_by_id_or_alias, kick_user,
28			unban_user,
29		},
30		profile::{delete_profile_field, get_profile, get_profile_field, set_profile_field},
31		room::{create_room, upgrade_room},
32		session::{
33			logout::v3::Request as LogoutRequest, logout_all::v3::Request as LogoutAllRequest,
34		},
35	},
36};
37use tuwunel_core::{Err, Result, utils::deadline_has_passed};
38use tuwunel_service::{Services, appservice::RegistrationInfo};
39
40pub(super) use self::dispatch::{AuthDispatch, Scheme};
41pub use self::uiaa::auth_uiaa;
42use super::request::Request;
43
44pub(super) enum Token {
45	Appservice(Box<RegistrationInfo>),
46	User((OwnedUserId, OwnedDeviceId, Option<SystemTime>)),
47	Expired,
48	Invalid,
49	None,
50}
51
52#[derive(Debug, Default)]
53pub(super) struct Auth {
54	pub(super) origin: Option<OwnedServerName>,
55	pub(super) sender_user: Option<OwnedUserId>,
56	pub(super) sender_device: Option<OwnedDeviceId>,
57	pub(super) appservice_info: Option<RegistrationInfo>,
58	pub(super) _expires_at: Option<SystemTime>,
59}
60
61#[tracing::instrument(level = "trace", skip_all, err(level = "debug"))]
62pub(super) async fn auth<A: AuthDispatch>(
63	services: &Services,
64	request: &mut Request,
65	json_body: Option<&CanonicalJsonValue>,
66	route: TypeId,
67) -> Result<Auth> {
68	let bearer: Option<TypedHeader<Authorization<Bearer>>> =
69		request.parts.extract().await.unwrap_or(None);
70
71	let access_token = match &bearer {
72		| Some(TypedHeader(Authorization(bearer))) => Some(bearer.token()),
73		| None => request.query.access_token.as_deref(),
74	};
75
76	// An expired token can still sign out, so a client can end a session it cannot resume.
77	let token = match find_token(services, access_token).await? {
78		| Token::User((_, _, expires_at))
79			if deadline_has_passed(expires_at) && !is_logout(route) =>
80			Token::Expired,
81
82		| token => token,
83	};
84
85	if A::SCHEME == Scheme::None {
86		check_auth_still_required(services, &token, route)?;
87	}
88
89	let auth = A::dispatch(services, request, json_body, token, route).await?;
90
91	try_join(
92		locked_account_check(services, &auth, route),
93		suspended_account_check(services, &auth, route),
94	)
95	.await?;
96
97	Ok(auth)
98}
99
100fn is_logout(route: TypeId) -> bool {
101	route == TypeId::of::<LogoutRequest>() || route == TypeId::of::<LogoutAllRequest>()
102}
103
104/// MSC3939: 401 `M_USER_LOCKED` for locked accounts; logout endpoints
105/// bypass. `soft_logout: true` is emitted by ruma for this errcode.
106#[inline(never)]
107async fn locked_account_check(services: &Services, auth: &Auth, route: TypeId) -> Result {
108	let Some(user_id) = auth.sender_user.as_deref() else {
109		return Ok(());
110	};
111
112	if is_logout(route) {
113		return Ok(());
114	}
115
116	services.users.locked_check(user_id).await
117}
118
119/// MSC3823: 403 `M_USER_SUSPENDED` on membership, room create/upgrade, and
120/// profile routes. Companion checks: self-redaction and self-leave carve-outs
121/// in the /send, /redact, and /state handlers; propagation in the profile
122/// service.
123#[inline(never)]
124async fn suspended_account_check(services: &Services, auth: &Auth, route: TypeId) -> Result {
125	let Some(user_id) = auth.sender_user.as_deref() else {
126		return Ok(());
127	};
128
129	let blocked = route == TypeId::of::<join_room_by_id::v3::Request>()
130		|| route == TypeId::of::<join_room_by_id_or_alias::v3::Request>()
131		|| route == TypeId::of::<invite_user::v3::Request>()
132		|| route == TypeId::of::<knock_room::v3::Request>()
133		|| route == TypeId::of::<kick_user::v3::Request>()
134		|| route == TypeId::of::<ban_user::v3::Request>()
135		|| route == TypeId::of::<unban_user::v3::Request>()
136		|| route == TypeId::of::<create_room::v3::Request>()
137		|| route == TypeId::of::<upgrade_room::v3::Request>()
138		|| route == TypeId::of::<set_profile_field::v3::Request>()
139		|| route == TypeId::of::<delete_profile_field::v3::Request>();
140
141	if !blocked || !services.users.is_suspended(user_id).await {
142		return Ok(());
143	}
144
145	Err!(Request(UserSuspended("Account is suspended.")))
146}
147
148#[inline(never)]
149fn check_auth_still_required(services: &Services, token: &Token, route: TypeId) -> Result {
150	let is_profile = route == TypeId::of::<get_profile::v3::Request>()
151		|| route == TypeId::of::<get_profile_field::v3::Request>();
152
153	let is_public_rooms = route == TypeId::of::<get_public_rooms::v3::Request>();
154
155	if (is_profile && services.server.config.profile.require_auth)
156		|| (is_public_rooms
157			&& !services
158				.server
159				.config
160				.directory
161				.rooms
162				.allow_without_auth)
163	{
164		match token {
165			| Token::Appservice(_) | Token::User(_) => Ok(()),
166			| Token::None | Token::Expired | Token::Invalid =>
167				Err!(Request(MissingToken("Missing or invalid access token."))),
168		}
169	} else {
170		Ok(())
171	}
172}
173
174async fn find_token(services: &Services, token: Option<&str>) -> Result<Token> {
175	let Some(token) = token else {
176		return Ok(Token::None);
177	};
178
179	let user_token = services
180		.users
181		.find_from_token(token)
182		.map_ok(Token::User);
183
184	let appservice_token = services
185		.appservice
186		.find_from_access_token(token)
187		.map_ok(Box::new)
188		.map_ok(Token::Appservice);
189
190	pin_mut!(user_token, appservice_token);
191	match select_ok([user_token.left_future(), appservice_token.right_future()]).await {
192		| Err(e) if !e.is_not_found() => Err(e),
193		| Ok((token, _)) => Ok(token),
194		| _ => Ok(Token::Invalid),
195	}
196}