Skip to main content

tuwunel_service/admin/
grant.rs

1use futures::FutureExt;
2use ruma::{
3	Int, OwnedUserId, RoomId, UserId,
4	events::{
5		StateEventType,
6		room::{
7			member::{MembershipState, RoomMemberEventContent},
8			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent, UserPowerLevel},
9		},
10	},
11};
12use tuwunel_core::{
13	Err, Result, debug_info, debug_warn, err, error, implement,
14	result::NotFound,
15	utils::{FutureBoolExt, future::ReadyBoolExt, stream::ReadyExt},
16};
17use tuwunel_matrix::pdu::PduBuilder;
18
19use super::notices::text_markdown;
20use crate::rooms::state::RoomMutexGuard;
21
22/// Invite the user to the tuwunel admin room.
23///
24/// This is equivalent to granting server admin privileges. A local user must
25/// already hold an account, or the grant would wait for whoever registers the
26/// name.
27#[implement(super::Service)]
28pub async fn make_user_admin(&self, user_id: &UserId) -> Result {
29	let is_local = self.services.globals.user_is_local(user_id);
30
31	if is_local && !self.services.users.exists(user_id).await {
32		return Err!(Request(NotFound("User {user_id} does not exist on this server.")));
33	}
34
35	let Ok(room_id) = self.get_admin_room().await else {
36		debug_warn!(
37			"make_user_admin was called without an admin room being available or created"
38		);
39		return Ok(());
40	};
41
42	let state_lock = self.services.state.mutex.lock(&room_id).await;
43
44	let is_joined = self
45		.services
46		.state_cache
47		.is_joined(user_id, &room_id)
48		.await;
49
50	let is_invited = self
51		.services
52		.state_cache
53		.is_invited(user_id, &room_id)
54		.await;
55
56	let already_member = is_joined || is_invited;
57
58	if !already_member {
59		self.invite_new_admin(user_id, &room_id, &state_lock)
60			.await?;
61	}
62
63	let server_user: &UserId = self.services.globals.server_user.as_ref();
64
65	let mut room_power_levels = self
66		.services
67		.state_accessor
68		.room_state_get_content::<RoomPowerLevelsEventContent>(
69			&room_id,
70			&StateEventType::RoomPowerLevels,
71			"",
72		)
73		.await
74		.unwrap_or_default();
75
76	let server_level = 69420.into();
77	let admin_level = 100.into();
78	let already_granted = room_power_levels.users.get(server_user) == Some(&server_level)
79		&& room_power_levels.users.get(user_id) == Some(&admin_level);
80
81	if !already_granted {
82		room_power_levels
83			.users
84			.insert(server_user.into(), server_level);
85		room_power_levels
86			.users
87			.insert(user_id.into(), admin_level);
88
89		self.services
90			.timeline
91			.build_and_append_pdu(
92				PduBuilder::state(String::new(), &room_power_levels),
93				server_user,
94				&room_id,
95				&state_lock,
96			)
97			.await?;
98	}
99
100	// Set room tag
101	let room_tag = self
102		.services
103		.server
104		.config
105		.admin
106		.room
107		.tag
108		.as_str();
109
110	if !already_granted
111		&& !room_tag.is_empty()
112		&& let Err(e) = self
113			.services
114			.account_data
115			.set_room_tag(user_id, &room_id, room_tag.into(), None)
116			.await
117	{
118		error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}");
119	}
120
121	if !already_member && self.services.server.config.admin.room.notices {
122		let welcome_message = "## Thank you for trying out tuwunel!\n\nTuwunel is a continuation of conduwuit which was technically a hard fork of Conduit.\n\nHelpful links:\n> GitHub Repo: https://github.com/matrix-construct/tuwunel\n> Documentation: https://matrix-construct.github.io/tuwunel\n> Report issues: https://github.com/matrix-construct/tuwunel/issues\n\nFor a list of available commands, send the following message in this room: `!admin --help`";
123
124		// Send welcome message
125		self.services
126			.timeline
127			.build_and_append_pdu(
128				PduBuilder::timeline(&text_markdown(welcome_message)),
129				server_user,
130				&room_id,
131				&state_lock,
132			)
133			.await?;
134	}
135
136	Ok(())
137}
138
139/// Grant room admin powers to a target by impersonating the highest-powered
140/// local member.
141///
142/// The target is granted the impersonated member's power level (100 when that
143/// member is a room-version 12 creator with infinite power), sent as a new
144/// `m.room.power_levels` from that member. When the room is non-public and the
145/// target is neither joined nor invited, the target is invited first.
146#[implement(super::Service)]
147pub async fn make_room_admin(&self, room_id: &RoomId, target: &UserId) -> Result {
148	let power_levels = self
149		.services
150		.state_accessor
151		.get_power_levels(room_id)
152		.await?;
153
154	let sender = self
155		.services
156		.state_cache
157		.local_users_in_room(room_id)
158		.ready_fold(None, |best: Option<(OwnedUserId, UserPowerLevel)>, user| {
159			let level = power_levels.for_user(user);
160			match best {
161				| Some((_, best_level)) if best_level >= level => best,
162				| _ => Some((user.to_owned(), level)),
163			}
164		})
165		.await;
166
167	let Some((sender, _)) = sender else {
168		return Err!(Request(InvalidParam("Server not in room")));
169	};
170
171	// Refuse before inviting when the chosen member cannot grant at all.
172	grantable_level(&power_levels, &sender)?;
173
174	let is_joined = self
175		.services
176		.state_cache
177		.is_joined(target, room_id);
178
179	let is_invited = self
180		.services
181		.state_cache
182		.is_invited(target, room_id);
183
184	let is_public = self.services.metadata.is_public(room_id);
185
186	// The membership probes lead; the public check is the multi-read leg.
187	let needs_invite = is_joined
188		.is_false()
189		.and2(is_invited.is_false(), is_public.is_false());
190
191	if needs_invite.await {
192		self.services
193			.membership
194			.invite(&sender, target, room_id, None, false)
195			.await?;
196	}
197
198	// After the invite, which locks this room's state itself; levels re-read under it.
199	let state_lock = self.services.state.mutex.lock(room_id).await;
200
201	let power_levels = self
202		.services
203		.state_accessor
204		.get_power_levels(room_id)
205		.await?;
206
207	let grant_level = grantable_level(&power_levels, &sender)?;
208
209	let mut content = self
210		.services
211		.state_accessor
212		.room_state_get_content::<RoomPowerLevelsEventContent>(
213			room_id,
214			&StateEventType::RoomPowerLevels,
215			"",
216		)
217		.await
218		.unwrap_or_default();
219
220	content.users.insert(target.into(), grant_level);
221
222	self.services
223		.timeline
224		.build_and_append_pdu(
225			PduBuilder::state(String::new(), &content),
226			&sender,
227			room_id,
228			&state_lock,
229		)
230		.await
231		.map(|_| ())
232}
233
234/// The power level `sender` grants, refused when it cannot send
235/// `m.room.power_levels`.
236///
237/// A room-version 12 creator's infinite power grants 100.
238fn grantable_level(power_levels: &RoomPowerLevels, sender: &UserId) -> Result<Int> {
239	if !power_levels.user_can_send_state(sender, StateEventType::RoomPowerLevels) {
240		return Err!(Request(InvalidParam(
241			"No local admin in room with power to update power levels"
242		)));
243	}
244
245	match power_levels.for_user(sender) {
246		| UserPowerLevel::Infinite => Ok(100.into()),
247		| UserPowerLevel::Int(level) => Ok(level),
248	}
249}
250
251#[implement(super::Service)]
252async fn invite_new_admin(
253	&self,
254	user_id: &UserId,
255	room_id: &RoomId,
256	state_lock: &RoomMutexGuard,
257) -> Result {
258	let server_user = self.services.globals.server_user.as_ref();
259
260	// if this is our local user, just forcefully join them in the room. otherwise,
261	// invite the remote user.
262	if self.services.globals.user_is_local(user_id) {
263		debug_info!("Inviting local user {user_id} to admin room {room_id}");
264		self.services
265			.timeline
266			.build_and_append_pdu(
267				PduBuilder::state(
268					String::from(user_id),
269					&RoomMemberEventContent::new(MembershipState::Invite),
270				),
271				server_user,
272				room_id,
273				state_lock,
274			)
275			.await?;
276
277		debug_info!("Force joining local user {user_id} to admin room {room_id}");
278		self.services
279			.timeline
280			.build_and_append_pdu(
281				PduBuilder::state(
282					String::from(user_id),
283					&RoomMemberEventContent::new(MembershipState::Join),
284				),
285				user_id,
286				room_id,
287				state_lock,
288			)
289			.await?;
290	} else {
291		debug_info!("Inviting remote user {user_id} to admin room {room_id}");
292		self.services
293			.timeline
294			.build_and_append_pdu(
295				PduBuilder::state(
296					user_id.to_string(),
297					&RoomMemberEventContent::new(MembershipState::Invite),
298				),
299				server_user,
300				room_id,
301				state_lock,
302			)
303			.await?;
304	}
305
306	Ok(())
307}
308
309/// Demote an admin, removing its rights.
310///
311/// Returns whether there was a grant to revoke. A user holding no invite, knock
312/// or join in the admin room has none, nor does anyone while there is no admin
313/// room, so the demotion is already done and nothing is written. The server
314/// user is refused, since the admin room exists only while the server user
315/// stays joined.
316#[implement(super::Service)]
317pub async fn revoke_admin(&self, user_id: &UserId) -> Result<bool> {
318	use MembershipState::{Invite, Join, Knock, Leave};
319
320	if user_id == self.services.globals.server_user {
321		return Err!(Request(InvalidParam("The server user's admin rights cannot be revoked.")));
322	}
323
324	let Some(room_id) = self.get_admin_room().await.present()? else {
325		return Ok(false);
326	};
327
328	let state_lock = self.services.state.mutex.lock(&room_id).await;
329
330	let Some(event) = self
331		.services
332		.state_accessor
333		.get_member(&room_id, user_id)
334		.await
335		.present()
336		.map_err(|e| err!(error!(?e, "Failure occurred while attempting revoke.")))?
337		.filter(|event| matches!(event.membership, Invite | Knock | Join))
338	else {
339		return Ok(false);
340	};
341
342	self.services
343		.timeline
344		.build_and_append_pdu(
345			PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
346				membership: Leave,
347				reason: Some("Admin Revoked".into()),
348				is_direct: false,
349				join_authorized_via_users_server: None,
350				third_party_invite: None,
351				..event
352			}),
353			self.services.globals.server_user.as_ref(),
354			&room_id,
355			&state_lock,
356		)
357		.boxed() // size firewall
358		.await
359		.map(|_| true)
360}