tuwunel_service/rooms/event_handler/
handle_outlier_pdu.rs1use 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 pdu_json.remove("unsigned");
36
37 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 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 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 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 debug!("Fetching auth events");
91 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 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 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}