Skip to main content

tuwunel_service/rooms/event_handler/
handle_outlier_pdu.rs

1use futures::{StreamExt, TryFutureExt};
2use ruma::{
3	CanonicalJsonObject, EventId, RoomId, RoomVersionId, ServerName, events::TimelineEventType,
4};
5use tuwunel_core::{
6	Err, Result, debug, debug_info, implement, trace,
7	utils::{ReadyExt, future::TryExtExt, stream::IterStream},
8	warn,
9};
10use tuwunel_matrix::{
11	Event, PduEvent, event::TypeExt, room::state::resolution::auth_check, room_version,
12};
13
14#[implement(super::Service)]
15#[cfg_attr(unabridged, tracing::instrument(
16    name = "outlier",
17    level = "debug",
18    skip_all,
19    fields(lev = %recursion_level)
20))]
21#[expect(clippy::too_many_arguments)]
22pub(super) async fn handle_outlier_pdu(
23	&self,
24	origin: &ServerName,
25	room_id: &RoomId,
26	event_id: &EventId,
27	mut pdu_json: CanonicalJsonObject,
28	room_version: &RoomVersionId,
29	recursion_level: usize,
30	auth_events_known: bool,
31) -> Result<(PduEvent, CanonicalJsonObject)> {
32	debug!(?event_id, ?auth_events_known, %recursion_level, "handle outlier");
33
34	// 1. Remove unsigned field
35	pdu_json.remove("unsigned");
36
37	// TODO: For RoomVersion6 we must check that Raw<..> is canonical do we
38	// anywhere?: https://matrix.org/docs/spec/rooms/v6#canonical-json
39	// 2. Check signatures, otherwise drop
40	// 3. check content hash, redact if doesn't match
41	let pdu_json = match self
42		.services
43		.server_keys
44		.verify_event(&pdu_json, Some(room_version))
45		.await
46	{
47		| Ok(ruma::signatures::Verified::All) => pdu_json,
48		| Ok(ruma::signatures::Verified::Signatures) => {
49			// Redact
50			debug_info!("Calculated hash does not match (redaction): {event_id}");
51			let Some(rules) = room_version.rules() else {
52				return Err!(Request(UnsupportedRoomVersion(
53					"Cannot redact event for unknown room version {room_version:?}."
54				)));
55			};
56
57			let Ok(pdu_json) = ruma::canonical_json::redact(pdu_json, &rules.redaction, None)
58			else {
59				return Err!(Request(InvalidParam("Redaction failed")));
60			};
61
62			// Skip the PDU if it is redacted and we already have it as an outlier event
63			if self.services.timeline.pdu_exists(event_id).await {
64				return Err!(Request(InvalidParam(
65					"Event was redacted and we already knew about it"
66				)));
67			}
68
69			pdu_json
70		},
71		| Err(e) => {
72			return Err!(Request(InvalidParam(debug_error!(
73				"Signature verification failed for {event_id}: {e}"
74			))));
75		},
76	};
77
78	// Now that we have checked the signature and hashes we can make mutations and
79	// convert to our PduEvent type.
80	let room_rules = room_version::rules(room_version)?;
81	let (event, pdu_json) =
82		PduEvent::from_object_federation(room_id, event_id, pdu_json, &room_rules)?;
83
84	if !auth_events_known {
85		// 4. fetch any missing auth events doing all checks listed here starting at 1.
86		//    These are not timeline events
87		// 5. Reject "due to auth events" if can't get all the auth events or some of
88		//    the auth events are also rejected "due to auth events"
89		// NOTE: Step 5 is not applied anymore because it failed too often
90		debug!("Fetching auth events");
91		// size firewall
92		Box::pin(self.fetch_auth(
93			origin,
94			room_id,
95			event.auth_events(),
96			room_version,
97			recursion_level,
98		))
99		.await;
100	}
101
102	// 6. Reject "due to auth events" if the event doesn't pass auth based on the
103	//    auth events
104	debug!("Checking based on auth events");
105
106	let is_hydra = !room_rules
107		.event_format
108		.allow_room_create_in_auth_events;
109
110	let not_create = *event.kind() != TimelineEventType::RoomCreate;
111	let hydra_create_id = (not_create && is_hydra)
112		.then(|| event.room_id().as_event_id().ok())
113		.flatten();
114
115	let auth_events: Vec<_> = event
116		.auth_events()
117		.chain(hydra_create_id.as_deref())
118		.stream()
119		.filter_map(|auth_event_id| {
120			self.event_fetch(auth_event_id)
121				.inspect_err(move |e| warn!("Missing auth_event {auth_event_id}: {e}"))
122				.ok()
123		})
124		.ready_filter_map(|auth_event| {
125			let state_key = auth_event.state_key()?;
126			let event_type = auth_event.event_type();
127
128			Some((event_type.with_state_key(state_key), auth_event))
129		})
130		.collect()
131		.await;
132
133	auth_check(&room_rules, &event, &*self.services.timeline, auth_events.as_slice())
134		.await?
135		.into_result()?;
136
137	trace!("Validation successful.");
138
139	// 7. Persist the event as an outlier.
140	self.services
141		.timeline
142		.add_pdu_outlier(event.event_id(), &pdu_json);
143
144	trace!("Added pdu as outlier.");
145
146	Ok((event, pdu_json))
147}