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 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#[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#[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}