Compare commits

..
31 changed files with 470 additions and 510 deletions

No files matched your search

+1 -1
View File
@@ -71,7 +71,7 @@ runs:
- name: Install timelord-cli and git-warp-time
if: steps.check-binaries.outputs.need-install == 'true'
uses: https://github.com/taiki-e/install-action@ab49d3c64680143e184118bed66a46419fc15519 # v2
uses: https://github.com/taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2
with:
tool: git-warp-time,timelord-cli@3.0.1
+1 -1
View File
@@ -43,7 +43,7 @@ jobs:
name: Renovate
runs-on: ubuntu-latest
container:
image: ghcr.io/renovatebot/renovate:44.241.0@sha256:22d22b4ca7d768b5b469309d34379783bf91cd94a58faecf1cd0f4528a65d21c
image: ghcr.io/renovatebot/renovate:44.227.4@sha256:e09d40686f73d43b2c1e4667cb47d3c1d24a6ac730b74ce7aced9c84f68594f1
options: --tmpfs /tmp:exec
steps:
- name: Checkout
Generated
-1
View File
@@ -949,7 +949,6 @@ dependencies = [
"sha1 0.11.0",
"tokio",
"tracing",
"wildmatch",
]
[[package]]
-3
View File
@@ -272,9 +272,6 @@ version = "0.5.2"
[workspace.dependencies.libloading]
version = "0.9.0"
[workspace.dependencies.wildmatch]
version = "2.7.0"
# Validating urls in config, was already a transitive dependency
[workspace.dependencies.url]
version = "2.5.8"
+3 -8
View File
@@ -23,15 +23,12 @@ to encourage users to stay up-to-date with the latest release, and we have no co
We appreciate the efforts of security researchers and the community in identifying and reporting vulnerabilities. To
ensure that potential vulnerabilities are addressed properly, please follow these guidelines:
1. **Contact _all_ members of the team** over E2EE private message on Matrix.
Add each contact to the same encrypted room. **Do not message maintainers individually**.
If you cannot reach us from matrix.org, please try [another server][sl] (e.g. continuwuity.rocks).
1. **Contact members of the team directly** over E2EE private message.
- [@jade:ellis.link](https://matrix.to/#/@jade:ellis.link)
- [@nex:nexy7574.co.uk](https://matrix.to/#/@nex:nexy7574.co.uk)
- [@ginger:gingershaped.computer](https://matrix.to/#/@ginger:gingershaped.computer)
2. **Email the security team** at [security@continuwuity.org](mailto:security@continuwuity.org). This is not E2EE, so
don't include sensitive details. Do not ask where to send sensitive details either; that
information is included in this security policy. We may not respond to emails that do this.
don't include sensitive details.
3. **Do not disclose the vulnerability publicly** until a fix has been pushed to the main branch.
4. **Provide detailed information** about the vulnerability, including:
- A clear description of the issue
@@ -45,8 +42,6 @@ ensure that potential vulnerabilities are addressed properly, please follow thes
If you have any doubts about a potential security vulnerability, contact us via private channels first! We'd prefer that
you bother us, instead of having a vulnerability disclosed without a fix.
[sl]: https://servers.joinmatrix.org
### Terms for credit
Before reporting a vulnerability, please remember that we are a small team maintaining a large codebase depended upon by
@@ -110,4 +105,4 @@ When security vulnerabilities are identified:
---
This security policy was last updated on November 17th, 2026.
This security policy was last updated on May 25, 2025.
+3 -17
View File
@@ -52,10 +52,8 @@ else
fi
# The base docker image to use for complement tests
# On Linux, you can build the default with `docker build -t continuwuity:complement -f ./docker/complement.Dockerfile .`
# after running `cargo build -p conduwuit --features openreg`.
# On non-Linux platforms (or to use a container build), build `docker/Dockerfile` with debuginfo and openreg `--build-arg RUST_PROFILE=dev --build-arg CARGO_FEATURES=default,openreg`
# and then run `docker build -t continuwuity:complement --target container -f ./docker/complement.Dockerfile .`.
# You can build the default with `docker build -t continuwuity:complement -f ./docker/complement.Dockerfile .`
# after running `cargo build -p conduwuit --features openreg`. Only the debug binary is used.
COMPLEMENT_BASE_IMAGE="${COMPLEMENT_BASE_IMAGE:-continuwuity:complement}"
# Complement tests that are skipped due to flakiness/reliability issues or we don't implement such features and won't for a long time
@@ -85,13 +83,6 @@ for command in docker go jq; do
fi
done
if [ -z "${DOCKER_HOST:-}" ]; then
DOCKER_HOST="$(docker context inspect --format '{{.Endpoints.docker.Host}}' 2>/dev/null || true)"
if [ -n "$DOCKER_HOST" ]; then
export DOCKER_HOST
fi
fi
if [ -n "$IMAGE_ARCHIVE" ]; then
if [ ! -f "$IMAGE_ARCHIVE" ]; then
echo "Docker image archive not found: $IMAGE_ARCHIVE"
@@ -108,12 +99,7 @@ fi
if ! docker image inspect "$COMPLEMENT_BASE_IMAGE" > /dev/null 2>&1; then
echo "Complement base image not found: $COMPLEMENT_BASE_IMAGE"
if [ "$(uname -s)" != "Linux" ]; then
echo "Build it with: docker buildx build --load -t continuwuity:latest-openreg --build-arg RUST_PROFILE=dev --build-arg CARGO_FEATURES=default,openreg -f docker/Dockerfile . && docker build -t $COMPLEMENT_BASE_IMAGE --target container -f docker/complement.Dockerfile ."
else
echo "Build it with: cargo build -p conduwuit --features openreg && docker build -t $COMPLEMENT_BASE_IMAGE -f docker/complement.Dockerfile ."
echo "Or from a container build: docker buildx build --load -t continuwuity:latest-openreg --build-arg RUST_PROFILE=dev --build-arg CARGO_FEATURES=default,openreg -f docker/Dockerfile . && docker build -t $COMPLEMENT_BASE_IMAGE --target container -f docker/complement.Dockerfile ."
fi
echo "Build it with: cargo build -p conduwuit --features openreg && docker build -t $COMPLEMENT_BASE_IMAGE -f docker/complement.Dockerfile ."
exit 1
fi
-1
View File
@@ -1 +0,0 @@
Legacy `/sync` now honours the `room.rooms`, `room.not_rooms`, `account_data.types` and `account_data.not_types` filter fields instead of returning every room and all account data. Contributed by @eleboucher.
-1
View File
@@ -1 +0,0 @@
Requests waiting on `/_matrix/client/v3/sync` can now be interrupted by the server shutdown, unblocking the 30-second shutdown delay imposed on a quiet server.
-1
View File
@@ -1 +0,0 @@
Fix remote server key signature verification when extra fields exist. Contributed by @hexchen
-1
View File
@@ -1 +0,0 @@
`/_matrix/client/v3/sync` no longer waits 30 seconds if the `timeout` parameter is omitted or set to zero, correctly reflecting the specification's rule that such requests should return immediately, even if they are empty.
-1
View File
@@ -1 +0,0 @@
The sticky events feature flag is correctly advertised in `/_matrix/client/versions` again after it was accidentally removed in #2517.
+3 -21
View File
@@ -1,29 +1,11 @@
ARG CONTINUWUITY_IMAGE=continuwuity:latest-openreg
ARG BINARY_SOURCE=host
FROM ${CONTINUWUITY_IMAGE} AS container-binary
FROM scratch AS host-binary
ARG BINARY_PATH=target/debug/conduwuit
COPY ${BINARY_PATH} /sbin/conduwuit
FROM ubuntu:latest AS base
FROM ubuntu:latest
EXPOSE 8008
EXPOSE 8448
RUN apt-get update && apt-get install -y ca-certificates liburing2 && rm -rf /var/lib/apt/lists/*
RUN mkdir -p /etc/continuwuity /var/lib/continuwuity /usr/local/bin/
COPY complement/complement-entrypoint.sh /usr/local/bin/complement-entrypoint.sh
COPY complement/complement.config.toml /etc/continuwuity/config.toml
RUN chmod +x /usr/local/bin/complement-entrypoint.sh
COPY target/debug/conduwuit /usr/local/bin/conduwuit
RUN chmod +x /usr/local/bin/conduwuit /usr/local/bin/complement-entrypoint.sh
#HEALTHCHECK --interval=30s --timeout=5s CMD curl --fail http://localhost:8008/_continuwuity/server_version || exit 1
ENTRYPOINT ["/usr/local/bin/complement-entrypoint.sh"]
FROM base AS container
COPY --from=container-binary /sbin/conduwuit /usr/local/bin/conduwuit
RUN chmod +x /usr/local/bin/conduwuit
FROM base AS host
COPY --from=host-binary /sbin/conduwuit /usr/local/bin/conduwuit
RUN chmod +x /usr/local/bin/conduwuit
FROM ${BINARY_SOURCE}
-14
View File
@@ -20,20 +20,6 @@ docker build -t continuwuity:complement -f docker/complement.Dockerfile .
The `openreg` feature is required: without it the server refuses the open
registrations Complement uses to create test users, and almost every test fails.
On non-Linux (or to build inside a container instead of on the host), build the Continuwuity image with the `openreg` feature and `RUST_PROFILE=dev` first (open
registration is only enabled when `debug_assertions` are active), then build
the Complement image using the `container` target:
```bash
docker buildx build --load -t continuwuity:latest-openreg --build-arg RUST_PROFILE=dev --build-arg CARGO_FEATURES=default,openreg -f docker/Dockerfile .
docker build -t continuwuity:complement --target container -f docker/complement.Dockerfile .
./bin/complement
```
Pass `--build-arg CONTINUWUITY_IMAGE=your-image:tag` when building
`docker/complement.Dockerfile` if your Continuwuity container image uses a
different tag.
The run can take up to an hour. The runner writes the full Go test stream to
`tests/test_results/complement/test_logs.jsonl` and a sorted pass/fail/skip
summary to `tests/test_results/complement/test_results.jsonl`. It exits nonzero
+2 -2
View File
@@ -142,11 +142,11 @@ impl crate::Context<'_> {
.await?;
self.write_str("| ------ | ---------- | --------------------------- |\n")
.await?;
for (key_id, key) in &response.parsed.verify_keys {
for (key_id, key) in &response.verify_keys {
self.write_str(&format!("| {key_id} | {} | |\n", key.key))
.await?;
}
for (key_id, old_key) in &response.parsed.old_verify_keys {
for (key_id, old_key) in &response.old_verify_keys {
self.write_str(&format!(
"| {key_id} | {} | {:0<13} |\n",
old_key.key,
-1
View File
@@ -87,7 +87,6 @@ serde.workspace = true
sha1.workspace = true
tokio.workspace = true
tracing.workspace = true
wildmatch.workspace = true
[lints]
workspace = true
+52 -75
View File
@@ -64,7 +64,7 @@ pub(super) async fn load_joined_room(
services: &Services,
sync_context: SyncContext<'_>,
ref room_id: OwnedRoomId,
) -> Result<JoinedRoom> {
) -> Result<(JoinedRoom, DeviceListUpdates)> {
/*
Building a sync response involves many steps which all depend on each other.
To parallelize the process as much as possible, each step is divided into its own function,
@@ -80,6 +80,7 @@ pub(super) async fn load_joined_room(
sticky,
summary,
notification_counts,
device_list_updates,
},
) = try_join3(
build_account_data(services, sync_context, room_id),
@@ -116,7 +117,7 @@ pub(super) async fn load_joined_room(
unread_thread_notifications: BTreeMap::new(),
});
Ok(joined_room)
Ok((joined_room, device_list_updates))
}
/// Collect changes to the syncing user's account data events.
@@ -262,6 +263,7 @@ struct StateAndTimeline {
sticky: Sticky,
summary: Option<RoomSummary>,
notification_counts: Option<UnreadNotificationsCount>,
device_list_updates: DeviceListUpdates,
}
async fn build_sticky_events(
@@ -375,14 +377,24 @@ async fn build_state_and_timeline(
debug_warn!("timeline for newly joined room is empty");
}
let summary = build_room_summary(
services,
sync_context,
room_id,
shortstatehashes,
&timeline,
&state_events,
joined_since_last_sync,
let (summary, device_list_updates) = try_join(
build_room_summary(
services,
sync_context,
room_id,
shortstatehashes,
&timeline,
&state_events,
joined_since_last_sync,
),
build_device_list_updates(
services,
sync_context,
room_id,
shortstatehashes,
&state_events,
joined_since_last_sync,
),
)
.await?;
@@ -418,6 +430,7 @@ async fn build_state_and_timeline(
sticky,
summary,
notification_counts,
device_list_updates,
})
}
@@ -841,34 +854,35 @@ async fn build_heroes(
.await
}
/// Collect updates to users' device lists for E2EE in a joined room.
#[tracing::instrument(level = "debug", skip_all, fields(%room_id))]
pub(super) async fn load_device_list_updates(
/// Collect updates to users' device lists for E2EE.
#[tracing::instrument(level = "debug", skip_all)]
async fn build_device_list_updates(
services: &Services,
sync_context: SyncContext<'_>,
room_id: &RoomId,
) -> Result<DeviceListUpdates> {
let SyncContext {
SyncContext {
syncing_user,
last_sync_end_count,
current_count,
..
} = sync_context;
let mut device_list_updates = DeviceListUpdates::new();
}: SyncContext<'_>,
room_id: &RoomId,
ShortStateHashes { current_shortstatehash, .. }: ShortStateHashes,
state_events: &Vec<PduEvent>,
joined_since_last_sync: bool,
) -> Result<DeviceListUpdates> {
let is_encrypted_room = services
.rooms
.state_accessor
.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")
.is_ok();
// initial syncs don't include device updates, and rooms which aren't
// encrypted don't affect them, so return early in either of those cases
if last_sync_end_count.is_none()
|| !services
.rooms
.state_accessor
.is_encrypted_room(room_id)
.await
{
return Ok(device_list_updates);
if last_sync_end_count.is_none() || !(is_encrypted_room.await) {
return Ok(DeviceListUpdates::new());
}
let mut device_list_updates = DeviceListUpdates::new();
// add users with changed keys to the `changed` list
services
.users
@@ -879,56 +893,19 @@ pub(super) async fn load_device_list_updates(
})
.await;
let shortstatehashes = fetch_shortstatehashes(services, sync_context, room_id).await?;
let ShortStateHashes {
current_shortstatehash,
last_sync_end_shortstatehash,
} = shortstatehashes;
if check_joined_since_last_sync(services, shortstatehashes, sync_context).await? {
// the syncing user now shares an encrypted room with every member
services
.rooms
.state_cache
.room_members(room_id)
.ready_for_each(|user_id| {
device_list_updates.changed.insert(user_id);
})
.await;
} else if let Some(last_sync_end_shortstatehash) = last_sync_end_shortstatehash
&& last_sync_end_shortstatehash != current_shortstatehash
{
// add users who now share encrypted rooms to `changed` and
// users who no longer share encrypted rooms to `left`
let state_added = services
.rooms
.state_accessor
.state_added((last_sync_end_shortstatehash, current_shortstatehash))
.await?;
for (shortstatekey, _) in state_added {
let Ok((StateEventType::RoomMember, state_key)) = services
.rooms
.short
.get_statekey_from_short(shortstatekey)
.await
// add users who now share encrypted rooms to `changed` and
// users who no longer share encrypted rooms to `left`
for state_event in state_events {
if state_event.kind == RoomMember {
let Some(content): Option<RoomMemberEventContent> = state_event.get_content().ok()
else {
continue;
};
let Ok(user_id) = OwnedUserId::try_from(state_key.as_str()) else {
continue;
};
let Ok(content): Result<RoomMemberEventContent> = services
.rooms
.state_accessor
.state_get_content(
current_shortstatehash,
&StateEventType::RoomMember,
user_id.as_str(),
)
.await
let Some(user_id): Option<OwnedUserId> = state_event
.state_key
.as_ref()
.and_then(|key| key.parse().ok())
else {
continue;
};
@@ -944,7 +921,7 @@ pub(super) async fn load_device_list_updates(
| Leave if !shares_encrypted_room => {
device_list_updates.left.insert(user_id);
},
| Join if shares_encrypted_room => {
| Join if joined_since_last_sync || shares_encrypted_room => {
device_list_updates.changed.insert(user_id);
},
| _ => (),
+21 -117
View File
@@ -3,6 +3,7 @@ mod left;
mod state;
use std::{
cmp::{self},
collections::{BTreeMap, HashMap, HashSet},
time::Duration,
};
@@ -20,7 +21,7 @@ use futures::{FutureExt, StreamExt, TryFutureExt, future::OptionFuture};
use ruma::{
DeviceId, OwnedUserId, RoomId, UserId,
api::client::{
filter::{self, FilterDefinition, RoomFilter},
filter::FilterDefinition,
sync::sync_events::{
self, DeviceLists,
v3::{
@@ -38,17 +39,13 @@ use service::{
account_data::AnyRawAccountDataEvent,
rooms::lazy_loading::{self, MemberSet, Options as _},
};
use wildmatch::WildMatch;
use super::{load_timeline, share_encrypted_room};
use crate::{
Ruma,
client::{
is_ignored_invite,
sync::v3::{
joined::{load_device_list_updates, load_joined_room},
left::load_left_room,
},
sync::v3::{joined::load_joined_room, left::load_left_room},
},
client_ip::ClientIp,
};
@@ -206,12 +203,7 @@ pub(crate) async fn sync_events_route(
let mut wake_receiver = services.sync.subscribe_to_wake(sender_user);
let response = build_sync_events(&services, &body).await?;
let timeout_duration = body.body.timeout.unwrap_or_default();
// If the timeout is zero, request has full_state=true, or there's
// meaningful data to return, do so immediately.
if timeout_duration.is_zero()
|| body.body.full_state
if body.body.full_state
|| !(response.rooms.is_empty()
&& response.presence.is_empty()
&& response.account_data.is_empty()
@@ -221,15 +213,11 @@ pub(crate) async fn sync_events_route(
return Ok(response);
}
// Otherwise, wait for a wake signal to rebuild changes. Cap timeout at 30
// seconds (this isn't specced, but a reasonable cap since most clients have
// a 30-second polling interval).
let duration = timeout_duration.min(Duration::from_secs(30));
let mut shutdown_signal = services.server.signal.subscribe();
tokio::select! {
_ = tokio::time::timeout(duration, wake_receiver.changed()) => {},
_ = shutdown_signal.recv() => return Err!(Request(Unknown("Server is shutting down"), SERVICE_UNAVAILABLE)),
};
// Hang a few seconds so requests are not spammed
// Stop hanging if new info arrives
let default = Duration::from_secs(30);
let duration = cmp::min(body.body.timeout.unwrap_or(default), default);
_ = tokio::time::timeout(duration, wake_receiver.changed()).await;
// Retry returning data
build_sync_events(&services, &body).await
@@ -283,47 +271,34 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_joined(syncing_user)
.ready_filter(|room_id| room_selected(&filter.room, room_id))
.broad_filter_map(|room_id| async {
let joined_room = load_joined_room(services, context, room_id.clone()).await;
match joined_room {
| Ok(room) => Some((room_id, room)),
| Ok((room, updates)) => Some((room_id, room, updates)),
| Err(err) => {
error!(?err, %room_id, "error loading joined room");
None
},
}
})
.ready_fold(BTreeMap::new(), |mut joined_rooms, (room_id, joined_room)| {
if !joined_room.is_empty() {
joined_rooms.insert(room_id, joined_room);
}
.ready_fold(
(BTreeMap::new(), DeviceListUpdates::new()),
|(mut joined_rooms, mut all_updates), (room_id, joined_room, updates)| {
all_updates.merge(updates);
joined_rooms
});
if !joined_room.is_empty() {
joined_rooms.insert(room_id, joined_room);
}
// a filtered out room still contributes its device list updates
let device_list_updates = services
.rooms
.state_cache
.rooms_joined(syncing_user)
.broad_filter_map(|room_id| async move {
load_device_list_updates(services, context, &room_id)
.await
.inspect_err(|err| error!(?err, %room_id, "error loading device list updates"))
.ok()
})
.ready_fold(DeviceListUpdates::new(), |mut all_updates, updates| {
all_updates.merge(updates);
all_updates
});
(joined_rooms, all_updates)
},
);
let left_rooms = services
.rooms
.state_cache
.rooms_left(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.broad_filter_map(|(room_id, leave_pdu)| async {
let left_room = load_left_room(services, context, room_id.clone(), leave_pdu).await;
@@ -342,7 +317,6 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_invited(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.wide_filter_map(async |(room_id, invite_state)| {
if is_ignored_invite(services, syncing_user, &room_id).await {
None
@@ -373,7 +347,6 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_knocked(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.fold_default(|mut knocked_rooms: BTreeMap<_, _>, (room_id, knock_state)| async move {
let knock_count = services
.rooms
@@ -403,13 +376,6 @@ pub(crate) async fn build_sync_events(
.account_data
.changes_since(None, syncing_user, last_sync_end_count, Some(current_count))
.ready_filter_map(|e| extract_variant!(e, AnyRawAccountDataEvent::Global))
.ready_filter(|event| {
event
.get_field::<String>("type")
.ok()
.flatten()
.is_some_and(|event_type| type_selected(&filter.account_data, &event_type))
})
.collect();
let to_device_events = services
@@ -438,8 +404,7 @@ pub(crate) async fn build_sync_events(
.list_unused_fallback_key_types(syncing_user, syncing_device);
let (
joined_rooms,
mut device_list_updates,
(joined_rooms, mut device_list_updates),
left_rooms,
invited_rooms,
knocked_rooms,
@@ -452,7 +417,6 @@ pub(crate) async fn build_sync_events(
) = async {
futures::join!(
joined_rooms,
device_list_updates,
left_rooms,
invited_rooms,
knocked_rooms,
@@ -501,24 +465,6 @@ pub(crate) async fn build_sync_events(
Ok(response)
}
fn room_selected(filter: &RoomFilter, room_id: &RoomId) -> bool {
!filter.not_rooms.iter().any(|not_room| not_room == room_id)
&& filter
.rooms
.as_ref()
.is_none_or(|rooms| rooms.iter().any(|room| room == room_id))
}
fn type_selected(filter: &filter::Filter, event_type: &str) -> bool {
let matches = |pattern: &String| WildMatch::new(pattern).matches(event_type);
!filter.not_types.iter().any(matches)
&& filter
.types
.as_ref()
.is_none_or(|types| types.iter().any(matches))
}
#[tracing::instrument(name = "presence", level = "debug", skip_all)]
async fn process_presence_updates(
services: &Services,
@@ -582,45 +528,3 @@ async fn prepare_lazily_loaded_members(
lazily_loaded_members
}
#[cfg(test)]
mod tests {
use ruma::{owned_room_id, room_id};
use super::*;
#[test]
fn rooms_filter_selects_rooms() {
let room_id = room_id!("!a:example.com");
let mut filter = RoomFilter::default();
assert!(room_selected(&filter, room_id));
filter.rooms = Some(Vec::new());
assert!(!room_selected(&filter, room_id));
filter.rooms = Some(vec![room_id.to_owned()]);
assert!(room_selected(&filter, room_id));
filter.not_rooms = vec![owned_room_id!("!a:example.com")];
assert!(!room_selected(&filter, room_id));
}
#[test]
fn types_filter_selects_account_data() {
let mut filter = filter::Filter::default();
assert!(type_selected(&filter, "m.direct"));
filter.types = Some(Vec::new());
assert!(!type_selected(&filter, "m.direct"));
filter.types = Some(vec!["m.direct".to_owned()]);
assert!(type_selected(&filter, "m.direct"));
filter.types = Some(vec!["m.*".to_owned()]);
assert!(type_selected(&filter, "m.direct"));
assert!(!type_selected(&filter, "im.ponies.user_emotes"));
filter.not_types = vec!["m.direct".to_owned()];
assert!(!type_selected(&filter, "m.direct"));
}
}
+3 -3
View File
@@ -34,7 +34,7 @@ pub(crate) async fn get_server_keys_route(
// We need to verify that this response is still trusted based on
// the current configuration. It's possible we got this response
// from a notary who we no longer trust.
if resp.parsed.valid_until_ts > in_one_week() {
if resp.valid_until_ts > in_one_week() {
continue;
}
let trusted = services.config.trusted_servers.iter().any(|notary| {
@@ -47,8 +47,8 @@ pub(crate) async fn get_server_keys_route(
if !trusted {
continue;
}
for (old_key_id, old_key) in resp.parsed.old_verify_keys {
if old_key.expired_ts > resp.parsed.valid_until_ts {
for (old_key_id, old_key) in resp.old_verify_keys {
if old_key.expired_ts > resp.valid_until_ts {
// This key expired in the future which is probably illegal
continue;
}
+27 -51
View File
@@ -44,7 +44,10 @@ use ruma::{
to_device::DeviceIdOrAllDevices,
};
use service::{
rooms::event_handler::{DagBuilderTree, build_local_dag},
rooms::{
event_handler::{DagBuilderTree, build_local_dag},
queue::QueueJob,
},
transactions::{FederationTxnState, TransactionError, TxnKey, WrappedTransactionResponse},
};
use tokio::sync::watch::{Receiver, Sender};
@@ -332,13 +335,6 @@ async fn handle_room(
room_id: OwnedRoomId,
pdus: impl Iterator<Item = Pdu> + Send,
) -> std::result::Result<Vec<(OwnedEventId, Result)>, TransactionError> {
let _room_lock = services
.rooms
.event_handler
.mutex_federation
.lock(room_id.as_str())
.await;
let room_id = &room_id;
let mut pdu_map: HashMap<OwnedEventId, CanonicalJsonObject> = pdus
.into_iter()
@@ -358,50 +354,30 @@ async fn handle_room(
let value = pdu_map
.remove(&event_id)
.expect("sorted event IDs must be from the original map");
services
.server
.check_running()
.map_err(|_| TransactionError::ShuttingDown)?;
let event_type = KeyValue::new(
"type",
pdu_type_label(value.get("type").and_then(CanonicalJsonValue::as_str)),
);
let origin_server_ts = value
.get("origin_server_ts")
.and_then(CanonicalJsonValue::as_integer)
.and_then(|ts| u64::try_from(i64::from(ts)).ok());
let room_id = match value
.get("room_id")
.and_then(CanonicalJsonValue::as_str)
.map(|v| v.try_into().map_err(Into::into))
{
| Some(Ok(v)) => v,
| Some(Err(e)) => {
results.push((event_id, Err(e)));
continue;
},
| None => {
results
.push((event_id, Err!(Request(BadJson("PDU is missing a room_id field")))));
continue;
},
};
let job = QueueJob {
room_id,
event_id: event_id.clone(),
origin: origin.to_owned(),
object: value,
};
let start = Instant::now();
let result = services
.rooms
.event_handler
.handle_incoming_pdu(origin, room_id, &event_id, value, false)
.boxed()
.await
.map(|_| ());
let outcome = KeyValue::new("outcome", match &result {
| Ok(()) => "accepted",
| Err(Error::BadRequest(ErrorKind::Forbidden, ..)) => "forbidden",
| Err(Error::BadRequest(ErrorKind::InvalidParam | ErrorKind::BadJson, ..)) =>
"invalid",
| Err(_) => "error",
});
let instruments = &services.server.metrics.instruments;
instruments
.federation_incoming_pdu_duration
.record(start.elapsed().as_secs_f64(), std::slice::from_ref(&outcome));
if let (Ok(()), Some(ts)) = (&result, origin_server_ts) {
let lag = millis_since_unix_epoch().saturating_sub(ts);
instruments
.federation_incoming_pdu_lag
.record(Duration::from_millis(lag).as_secs_f64(), &[]);
}
instruments
.federation_incoming_pdus
.add(1, &[event_type, outcome]);
results.push((event_id, result));
results.push((event_id, services.rooms.queue.new_job(job).await));
}
Ok(results)
}
+2 -5
View File
@@ -35,10 +35,10 @@ pub fn versions() -> Vec<String> {
pub fn unstable_features(experiments: &Experiments) -> BTreeMap<String, bool> {
BTreeMap::from_iter([
// MatrixRTC (https://github.com/matrix-org/matrix-spec-proposals/pull/4143)
// Expected for spec v1.20/v2.0
// Expected for spec v1.20
("org.matrix.msc4143".to_owned(), true),
// Simplified Sliding sync (https://github.com/matrix-org/matrix-spec-proposals/pull/4186)
// Expected for spec v1.20/v2.0
// Expected for spec v1.20
("org.matrix.simplified_msc3575".to_owned(), true),
("org.matrix.msc4155".to_owned(), experiments.msc4155.is_enabled()),
// profile change propagation (https://github.com/matrix-org/matrix-spec-proposals/pull/4466)
@@ -48,8 +48,5 @@ pub fn unstable_features(experiments: &Experiments) -> BTreeMap<String, bool> {
("org.continuwuity.msc4484.unstable".to_owned(), experiments.msc4484.is_enabled()),
("org.continuwuity.msc4560".to_owned(), experiments.msc4560.is_enabled()),
("fi.mau.msc2815".to_owned(), experiments.msc2815.is_enabled()),
// Sticky events (https://github.com/matrix-org/matrix-spec-proposals/pull/4354)
// Proposal merged, expected for spec v1.20/v2.0
("org.matrix.msc4354".to_owned(), true),
])
}
+1 -1
View File
@@ -25,7 +25,7 @@ http.workspace = true
ruma.workspace = true
serde = { workspace = true }
serde_json = { workspace = true }
wildmatch.workspace = true
wildmatch = "2.7.0"
[dev-dependencies]
+30 -29
View File
@@ -11,8 +11,8 @@ version.workspace = true
[lib]
path = "mod.rs"
crate-type = [
"rlib",
# "dylib",
"rlib",
# "dylib",
]
[features]
@@ -23,61 +23,61 @@ bindgen-static = [
"conduwuit-database/bindgen-static"
]
brotli_compression = [
"conduwuit-core/brotli_compression",
"reqwest/brotli",
"conduwuit-core/brotli_compression",
"reqwest/brotli",
]
console = [
"dep:rustyline-async",
"dep:termimad",
"dep:rustyline-async",
"dep:termimad",
]
element_hacks = []
gzip_compression = [
"conduwuit-core/gzip_compression",
"reqwest/gzip",
"conduwuit-core/gzip_compression",
"reqwest/gzip",
]
http3 = [
"reqwest/http3"
]
io_uring = [
"conduwuit-database/io_uring",
"conduwuit-database/io_uring",
]
jemalloc = [
"conduwuit-core/jemalloc",
"conduwuit-database/jemalloc",
"conduwuit-core/jemalloc",
"conduwuit-database/jemalloc",
]
jemalloc_conf = [
"conduwuit-core/jemalloc_conf",
"conduwuit-database/jemalloc_conf",
"conduwuit-core/jemalloc_conf",
"conduwuit-database/jemalloc_conf",
]
jemalloc_prof = [
"conduwuit-core/jemalloc_prof",
"conduwuit-database/jemalloc_prof",
"conduwuit-core/jemalloc_prof",
"conduwuit-database/jemalloc_prof",
]
jemalloc_stats = [
"conduwuit-core/jemalloc_stats",
"conduwuit-database/jemalloc_stats",
"conduwuit-core/jemalloc_stats",
"conduwuit-database/jemalloc_stats",
]
media_thumbnail = [
"dep:image",
"dep:image",
]
release_max_log_level = [
"conduwuit-core/release_max_log_level",
"conduwuit-database/release_max_log_level",
"log/max_level_trace",
"log/release_max_level_info",
"tracing/max_level_trace",
"tracing/release_max_level_info",
"conduwuit-core/release_max_log_level",
"conduwuit-database/release_max_log_level",
"log/max_level_trace",
"log/release_max_level_info",
"tracing/max_level_trace",
"tracing/release_max_level_info",
]
systemd = [
"dep:sd-notify",
"dep:sd-notify",
]
url_preview = [
"dep:image",
"dep:webpage",
"dep:image",
"dep:webpage",
]
zstd_compression = [
"conduwuit-core/zstd_compression",
"conduwuit-database/zstd_compression",
"conduwuit-core/zstd_compression",
"conduwuit-database/zstd_compression",
"reqwest/zstd",
]
@@ -135,6 +135,7 @@ openidconnect.workspace = true
# which is necessary to call `danger_accept_invalid_certs`.
reqwest_0_12.workspace = true
rand.workspace = true
opentelemetry.workspace = true
[target.'cfg(all(unix, target_os = "linux"))'.dependencies]
sd-notify.workspace = true
+1 -1
View File
@@ -534,7 +534,7 @@ impl Service {
return state;
},
};
if !pdu_fits(&value) {
if !pdu_fits(&value.clone()) {
warn!(
"dropping incoming PDU {event_id} in room {room_id} from room join \
because it exceeds 65535 bytes or is otherwise too large."
+2
View File
@@ -7,6 +7,7 @@ pub mod membership;
pub mod metadata;
pub mod outlier;
pub mod pdu_metadata;
pub mod queue;
pub mod read_receipt;
pub mod search;
pub mod short;
@@ -32,6 +33,7 @@ pub struct Service {
pub metadata: Arc<metadata::Service>,
pub outlier: Arc<outlier::Service>,
pub pdu_metadata: Arc<pdu_metadata::Service>,
pub queue: Arc<queue::Service>,
pub read_receipt: Arc<read_receipt::Service>,
pub search: Arc<search::Service>,
pub short: Arc<short::Service>,
+240
View File
@@ -0,0 +1,240 @@
use std::{
collections::{HashMap, hash_map::Entry},
sync::Arc,
time::{Duration, Instant},
};
use async_trait::async_trait;
use conduwuit::{
Error, Result, Server, SyncMutex, debug, err, error, info, utils::millis_since_unix_epoch,
};
use opentelemetry::KeyValue;
use ruma::{
CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName,
api::error::ErrorKind, events::TimelineEventType,
};
use tokio::{
sync::{
Notify, mpsc,
mpsc::{Sender, UnboundedReceiver, UnboundedSender},
},
task::JoinSet,
};
use crate::{
rooms,
service::{Args, Dep},
};
pub struct Services {
event_handler: Dep<rooms::event_handler::Service>,
server: Arc<Server>,
}
pub struct Service {
queues: SyncMutex<HashMap<OwnedRoomId, UnboundedSender<QueueJob>>>,
send: Sender<QueueJob>,
recv: tokio::sync::Mutex<mpsc::Receiver<QueueJob>>,
shutdown: Notify,
services: Services,
}
#[async_trait]
impl crate::Service for Service {
fn build(args: Args<'_>) -> Result<Arc<Self>>
where
Self: Sized,
{
let (send, recv) = mpsc::channel(1);
Ok(Arc::new(Self {
queues: SyncMutex::new(HashMap::new()),
shutdown: Notify::new(),
send,
recv: tokio::sync::Mutex::new(recv),
services: Services {
event_handler: args.depend("rooms::event_handler"),
server: args.server.clone(),
},
}))
}
async fn worker(self: Arc<Self>) -> Result<()> {
let mut recv = self.recv.lock().await;
let mut handles = JoinSet::new();
let (yielder, mut yielding) = mpsc::channel(5);
loop {
let job = tokio::select! {
() = self.shutdown.notified() => {
info!("Shutting down");
yielding.close();
recv.close();
break;
},
room_id = yielding.recv() => {
if let Some(room_id) = room_id {
self.queues.lock().remove(&room_id);
}
continue;
}
job = recv.recv() => job
};
let Some(job) = job else {
debug!("No job (channel closed)");
break;
};
let mut queues = self.queues.lock();
match queues.entry(job.room_id.clone()) {
| Entry::Occupied(entry) => {
entry.get().send(job).unwrap();
// TODO: handle error
// It might be possible for a self-reaping worker to close
// at the same time we try to send to it, which will cause
// this send to return a "channel closed" error.
},
| Entry::Vacant(entry) => {
let room_id = entry.key().to_owned();
let (sender, receiver) = mpsc::unbounded_channel();
sender.send(job).unwrap(); // TODO: handle error
handles.spawn_on(
Self::room_worker(self.clone(), room_id, receiver, yielder.clone()),
self.services.server.runtime(),
);
entry.insert(sender);
},
}
}
// If the loop broke, make sure that the shutdown signal was sent, so
// that any room workers are guaranteed to shut down as soon as
// possible.
self.interrupt();
while let Some(ret) = handles.join_next_with_id().await {
match ret {
| Ok((id, ())) => {
debug!(?id, "room queue worker finished");
},
| Err(error) => {
error!(id = ?error.id(), ?error, "room queue worker failed");
},
}
}
Ok(())
}
fn interrupt(&self) { self.shutdown.notify_waiters(); }
fn name(&self) -> &'static str { module_path!() }
}
impl Service {
pub async fn new_job(&self, job: QueueJob) -> Result<()> {
self.send
.send(job)
.await
.map_err(|e| err!("failed to send PDU to worker: {e}"))
}
#[tracing::instrument(skip(self,channel,yielder), fields(%room_id))]
async fn room_worker(
self: Arc<Self>,
room_id: OwnedRoomId,
mut channel: UnboundedReceiver<QueueJob>,
yielder: Sender<OwnedRoomId>,
) {
debug!("Room worker starting up");
loop {
let job = tokio::select! {
() = self.shutdown.notified() => {
debug!("Room worker shutting down");
channel.close();
return;
},
() = tokio::time::sleep(Duration::from_mins(5)) => {
debug!("Room worker self-reaping (no activity in 5 minutes)");
yielder.send(room_id).await.ok();
debug!("Room worker reaped. Goodbye.");
return;
},
job = channel.recv() => job
};
let Some(job) = job else {
debug!("Room worker channel closed without shutdown?");
break;
};
debug!(
event_id=%job.event_id,
origin=%job.origin,
backpressure=%channel.len(),
"Handling incoming job"
);
let _room_lock = self
.services
.event_handler
.mutex_federation
.lock(room_id.as_str())
.await;
debug!(event_id=%job.event_id, origin=%job.origin, "Acquired room federation lock");
let event_type = KeyValue::new(
"type",
pdu_type_label(job.object.get("type").and_then(CanonicalJsonValue::as_str)),
);
let origin_server_ts = job
.object
.get("origin_server_ts")
.and_then(CanonicalJsonValue::as_integer)
.and_then(|ts| u64::try_from(i64::from(ts)).ok());
let start = Instant::now();
let result = self
.services
.event_handler
.handle_incoming_pdu(&job.origin, &job.room_id, &job.event_id, job.object, false)
.await;
let outcome = KeyValue::new("outcome", match &result {
| Ok(_) => "accepted",
| Err(Error::BadRequest(ErrorKind::Forbidden, ..)) => "forbidden",
| Err(Error::BadRequest(ErrorKind::InvalidParam | ErrorKind::BadJson, ..)) =>
"invalid",
| Err(_) => "error",
});
let instruments = &self.services.server.metrics.instruments;
instruments
.federation_incoming_pdu_duration
.record(start.elapsed().as_secs_f64(), std::slice::from_ref(&outcome));
if let (Ok(_), Some(ts)) = (&result, origin_server_ts) {
let lag = millis_since_unix_epoch().saturating_sub(ts);
instruments
.federation_incoming_pdu_lag
.record(Duration::from_millis(lag).as_secs_f64(), &[]);
}
instruments
.federation_incoming_pdus
.add(1, &[event_type, outcome]);
debug!(event_id=%job.event_id, origin=%job.origin, "Job finished");
}
}
}
pub struct QueueJob {
pub origin: OwnedServerName,
pub event_id: OwnedEventId,
pub room_id: OwnedRoomId,
pub object: CanonicalJsonObject,
}
/// Known event types, or `other`, so remote servers cannot create new
/// attribute values.
fn pdu_type_label(event_type: Option<&str>) -> String {
match event_type.map(TimelineEventType::from) {
| Some(TimelineEventType::_Custom(_)) | None => "other".to_owned(),
| Some(event_type) => event_type.to_string(),
}
}
+4 -4
View File
@@ -54,7 +54,7 @@ pub fn pdu_fits(owned_obj: &CanonicalJsonObject) -> bool {
}
// Now check the full PDU size
match serde_json::to_string(owned_obj) {
| Ok(s) => s.len() <= 65536,
| Ok(s) => s.len() <= 65535,
| Err(_) => false,
}
}
@@ -305,7 +305,7 @@ impl super::Service {
{
return match e {
| Error::SignatureJson(ruma::signatures::JsonError::PduTooLarge) => {
Err!(Request(TooLarge("Message/PDU is too long (exceeds 65536 bytes)")))
Err!(Request(TooLarge("Message/PDU is too long (exceeds 65535 bytes)")))
},
| _ => Err!(Request(Unknown(warn!("Signing event failed: {e}")))),
};
@@ -330,9 +330,9 @@ impl super::Service {
pdu_json
.insert("event_id".into(), CanonicalJsonValue::String(pdu.event_id.clone().into()));
// Verify that the *full* PDU isn't over 64KiB.
if !pdu_fits(&pdu_json) {
if !pdu_fits(&pdu_json.clone()) {
// feckin huge PDU mate
return Err!(Request(TooLarge("Message/PDU is too long (exceeds 65536 bytes)")));
return Err!(Request(TooLarge("Message/PDU is too long (exceeds 65535 bytes)")));
}
// Check with the policy server
+9 -9
View File
@@ -241,9 +241,9 @@ impl super::Service {
continue;
}
};
trace!(?origin_response.raw, "Got signing key response from origin");
trace!(?origin_response, "Got signing key response from origin");
self.add_signing_keys(&origin_response);
Self::track_result(&mut result, &mut still_missing, &origin_response.parsed);
Self::track_result(&mut result, &mut still_missing, &origin_response);
if still_missing.is_empty() {
break;
}
@@ -262,9 +262,9 @@ impl super::Service {
"Got signing keys response from a notary"
);
for server_keys in notary_response {
trace!(?server_keys.raw, "Adding response from notary");
trace!(?server_keys, "Adding response from notary");
self.add_signing_keys(&server_keys);
Self::track_result(&mut result, &mut still_missing, &server_keys.parsed);
Self::track_result(&mut result, &mut still_missing, &server_keys);
if still_missing.is_empty() {
break;
}
@@ -285,9 +285,9 @@ impl super::Service {
continue;
};
for server_keys in res {
trace!(?server_keys.raw, "Adding response from notary");
trace!(?server_keys, "Adding response from notary");
self.add_signing_keys(&server_keys);
Self::track_result(&mut result, &mut still_missing, &server_keys.parsed);
Self::track_result(&mut result, &mut still_missing, &server_keys);
}
if still_missing.is_empty() {
break;
@@ -300,9 +300,9 @@ impl super::Service {
debug_warn!(err=?res.err(), "Got error response from origin");
continue;
};
trace!(response=?res.raw, "Got signing key response from origin");
trace!(response=?res, "Got signing key response from origin");
self.add_signing_keys(&res);
Self::track_result(&mut result, &mut still_missing, &res.parsed);
Self::track_result(&mut result, &mut still_missing, &res);
if still_missing.is_empty() {
break;
}
@@ -400,7 +400,7 @@ impl super::Service {
.inspect_err(|e| info!("Could not acquire signing key from origin server: {e:?}"))
.ok()?;
verify_key_from_response(key_id, &response.parsed, min_valid_ts)
verify_key_from_response(key_id, &response, min_valid_ts)
.inspect(|_| self.add_signing_keys(&response))
}
}
+7 -13
View File
@@ -19,10 +19,8 @@ use ruma::{
ServerSigningKeyId,
api::federation::discovery::{ServerSigningKeys, VerifyKey},
room_version_rules::RoomVersionRules,
serde::Raw,
signatures::{Ed25519KeyPair, PublicKeyMap, PublicKeySet},
};
use verify::IncomingServerKeys;
use crate::{Dep, globals, sending, server_keys::util::required_keys};
@@ -85,22 +83,19 @@ impl Service {
}
/// Adds a signing key response to the database.
fn add_signing_keys(&self, new_keys: &IncomingServerKeys) {
fn add_signing_keys(&self, new_keys: &ServerSigningKeys) {
// TODO(nex): this results in massive amounts of data duplication.
// Perhaps a sliding approach would be better? where we just update the
// last known response if the only thing that changed was the
// valid_until_ts. This would require a more complex data structure
// though. For now, just storing the duplicated data is fine.
for key in new_keys
.parsed
.verify_keys
.keys()
.chain(new_keys.parsed.old_verify_keys.keys())
.chain(new_keys.old_verify_keys.keys())
{
let db_key = (new_keys.parsed.server_name.as_str(), key.as_str());
self.db
.servernamekeyid_response
.put(db_key, Json(&new_keys.raw));
let db_key = (new_keys.server_name.as_str(), key.as_str());
self.db.servernamekeyid_response.put(db_key, Json(new_keys));
}
}
@@ -175,7 +170,7 @@ impl Service {
let mut keys = self
.signing_keys_for(origin)
.ready_fold(BTreeMap::new(), |mut base, keys| {
base.extend(keys.parsed.verify_keys);
base.extend(keys.verify_keys);
base
})
.await;
@@ -191,12 +186,11 @@ impl Service {
pub fn signing_keys_for<'a>(
&'a self,
origin: &'a ServerName,
) -> impl Stream<Item = IncomingServerKeys> + Send + 'a {
) -> impl Stream<Item = ServerSigningKeys> + Send + 'a {
self.db
.servernamekeyid_response
.stream_prefix(&(origin, Interfix))
.ignore_err()
.map(|(_, v): (Ignore, Raw<ServerSigningKeys>)| v.try_into().map_err(Into::into))
.ignore_err()
.map(|(_, v): (Ignore, ServerSigningKeys)| v)
}
}
+28 -36
View File
@@ -4,6 +4,7 @@ use conduwuit::{Err, Result, trace, utils::millis_since_unix_epoch, warn};
use ruma::{
MilliSecondsSinceUnixEpoch, OwnedServerName, OwnedServerSigningKeyId, ServerName, UInt,
api::federation::discovery::{
ServerSigningKeys,
get_remote_server_keys_batch::{
self,
v2::{QueryCriteria, Response as NotaryResponse},
@@ -14,8 +15,6 @@ use ruma::{
uint,
};
use crate::server_keys::verify::IncomingServerKeys;
pub(crate) type ServerKeysQuery = BTreeMap<OwnedServerName, ServerKeysQuerySet>;
pub(crate) type ServerKeysQuerySet = BTreeMap<OwnedServerSigningKeyId, QueryCriteria>;
@@ -28,33 +27,32 @@ impl super::Service {
&self,
target: OwnedServerName,
min_valid_ts: MilliSecondsSinceUnixEpoch,
) -> Result<IncomingServerKeys> {
) -> Result<ServerSigningKeys> {
use get_server_keys::v2::Request;
let raw_server_key = self
let server_signing_key = self
.services
.sending
.send_unauthenticated_request(&target, Request::new())
.await
.map(|response| response.server_key)?;
.map(|response| response.server_key)
.and_then(|key| key.deserialize().map_err(Into::into))?;
let server_signing_key: IncomingServerKeys = raw_server_key.try_into()?;
if server_signing_key.parsed.server_name != target {
if server_signing_key.server_name != target {
return Err!(BadServerResponse(debug_warn!(
requested = ?target,
response = ?server_signing_key.parsed.server_name,
response = ?server_signing_key.server_name,
"Origin server responded with bogus server_name"
)));
}
if server_signing_key.parsed.valid_until_ts < min_valid_ts
|| server_signing_key.parsed.valid_until_ts > in_one_week()
if server_signing_key.valid_until_ts < min_valid_ts
|| server_signing_key.valid_until_ts > in_one_week()
{
return Err!(BadServerResponse(debug_warn!(
?target,
?min_valid_ts,
?server_signing_key.parsed.valid_until_ts,
?server_signing_key.valid_until_ts,
"Origin server responded with server keys that are not in-date"
)));
}
@@ -85,7 +83,7 @@ impl super::Service {
&self,
notary: &ServerName,
batch: ServerKeysQuery,
) -> Result<Vec<IncomingServerKeys>> {
) -> Result<Vec<ServerSigningKeys>> {
use get_remote_server_keys_batch::v2::Request;
let is_empty = batch.is_empty() || batch.values().all(BTreeMap::is_empty);
@@ -118,12 +116,12 @@ impl super::Service {
}
/// Parses a notary response, returning a vec of server signing key
/// responses, each paired with its raw JSON (which is what the signatures
/// were made over). Drops any chunks that cannot be deserialized.
fn parse_notary_response(raw: &NotaryResponse) -> Vec<IncomingServerKeys> {
/// responses. Drops any chunks that cannot be deserialized.
fn parse_notary_response(raw: &NotaryResponse) -> Vec<ServerSigningKeys> {
raw.server_keys
.iter()
.filter_map(|chunk| chunk.try_into().ok())
.map(ruma::serde::Raw::deserialize)
.filter_map(Result::ok)
.collect()
}
@@ -131,15 +129,12 @@ impl super::Service {
/// if the response should be dropped, true if it should be kept.
fn validate_notary_chunk(
batch: &ServerKeysQuery,
incoming: &IncomingServerKeys,
keys: &ServerSigningKeys,
notary_name: &ServerName,
notary_keys: &[Base64],
) -> bool {
let Some(expected_keys) = batch.get(&incoming.parsed.server_name) else {
trace!(
"Dropping signing keys chunk for unrequested server: {}",
incoming.parsed.server_name
);
let Some(expected_keys) = batch.get(&keys.server_name) else {
trace!("Dropping signing keys chunk for unrequested server: {}", keys.server_name);
return false;
};
let min_valid_ts = expected_keys
@@ -153,15 +148,13 @@ impl super::Service {
// If this notary response is older than any of the min_valid_ts we
// requested, then we should drop it.
if incoming.parsed.valid_until_ts < min_valid_ts
|| incoming.parsed.valid_until_ts > in_one_week()
{
if keys.valid_until_ts < min_valid_ts || keys.valid_until_ts > in_one_week() {
trace!(
?min_valid_ts,
?incoming.parsed.valid_until_ts,
?keys.valid_until_ts,
"Dropping signing keys chunk for server {} because it is older than the minimum \
valid timestamp we requested",
incoming.parsed.server_name
keys.server_name
);
return false;
}
@@ -169,39 +162,38 @@ impl super::Service {
// Does this chunk even contain any keys we asked for?
// Note that this enforces min_valid_ts per-key, instead of using the
// lowest denominator.
let all_key_ids = incoming
.parsed
let all_key_ids = keys
.verify_keys
.keys()
.chain(incoming.parsed.old_verify_keys.keys())
.chain(keys.old_verify_keys.keys())
.map(ToOwned::to_owned)
.collect::<Vec<_>>();
let interesting = expected_keys.iter().any(|(k, q)| {
all_key_ids.contains(k)
&& q.minimum_valid_until_ts
.is_none_or(|m| m <= incoming.parsed.valid_until_ts)
.is_none_or(|m| m <= keys.valid_until_ts)
});
if !interesting {
trace!(
"Dropping signing keys chunk for server {} because it does not contain any keys \
we requested",
incoming.parsed.server_name
keys.server_name
);
return false;
}
Self::verify_server_keys_response(incoming, Some((notary_name, notary_keys)))
Self::verify_server_keys_response(keys, Some((notary_name, notary_keys)))
.inspect_err(|e| {
trace!(
?e,
?incoming.raw,
?keys,
?notary_name,
?notary_keys,
"Dropping illegal server signing keys response chunk"
);
warn!(
%notary_name,
server_name=%incoming.parsed.server_name,
server_name=%keys.server_name,
"Dropping illegal server signing keys response chunk: {e:?}"
);
})
+29 -92
View File
@@ -5,36 +5,11 @@ use ruma::{
CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, ServerName, SigningKeyAlgorithm,
api::federation::discovery::ServerSigningKeys,
room_version_rules::RoomVersionRules,
serde::{Base64, Raw, base64::Standard},
serde::{Base64, base64::Standard},
signatures::Verified,
};
use serde_json::value::RawValue as RawJsonValue;
pub struct IncomingServerKeys {
pub raw: Raw<ServerSigningKeys>,
pub parsed: ServerSigningKeys,
}
impl TryFrom<Raw<ServerSigningKeys>> for IncomingServerKeys {
type Error = serde_json::Error;
fn try_from(value: Raw<ServerSigningKeys>) -> std::result::Result<Self, Self::Error> {
value
.deserialize()
.map(|parsed| Self { raw: value, parsed })
}
}
impl TryFrom<&Raw<ServerSigningKeys>> for IncomingServerKeys {
type Error = serde_json::Error;
fn try_from(value: &Raw<ServerSigningKeys>) -> std::result::Result<Self, Self::Error> {
value
.deserialize()
.map(|parsed| Self { raw: value.to_owned(), parsed })
}
}
impl super::Service {
/// Validates the incoming event only using locally known verification keys.
/// Inserts the calculated event ID into the event_id field upon success.
@@ -83,38 +58,34 @@ impl super::Service {
/// `notary` must either be empty or have ONE entry. Extraneous notaries
/// will be ignored.
pub fn verify_server_keys_response(
incoming: &IncomingServerKeys,
server_keys: &ServerSigningKeys,
notary: Option<(&ServerName, &[Base64])>,
) -> Result<()> {
if let Some((notary_name, notary_keys)) = notary {
if !notary_keys.is_empty() {
Self::verify_notary_signature(incoming, notary_name, notary_keys)?;
Self::verify_notary_signature(server_keys, notary_name, notary_keys)?;
}
}
// NOTE: old_verify_keys aren't considered here because old keys can't
// be used to sign key responses.
let mut set = ruma::signatures::PublicKeySet::new();
incoming
.parsed
.verify_keys
.iter()
.for_each(|(key_id, key)| {
set.insert(key_id.to_string(), key.key.clone());
});
server_keys.verify_keys.iter().for_each(|(key_id, key)| {
set.insert(key_id.to_string(), key.key.clone());
});
let mut pubkey_map = ruma::signatures::PublicKeyMap::new();
pubkey_map.insert(incoming.parsed.server_name.to_string(), set);
pubkey_map.insert(server_keys.server_name.to_string(), set);
let mut canonical = to_canonical_object(&incoming.raw)?;
Self::strip_extraneous_signatures(&mut canonical, &incoming.parsed.server_name, &[]);
let mut canonical = to_canonical_object(server_keys)?;
Self::strip_extraneous_signatures(&mut canonical, &server_keys.server_name, &[]);
ruma::signatures::verify_json(&pubkey_map, &canonical).map_err(Into::into)
}
/// Verifies that the notary has at least one valid signature present with
/// the provided signing keys.
fn verify_notary_signature(
incoming: &IncomingServerKeys,
server_keys: &ServerSigningKeys,
notary_name: &ServerName,
notary_keys: &[Base64],
) -> Result<()> {
@@ -123,16 +94,19 @@ impl super::Service {
// certificate has been compromised, which would otherwise allow
// them to produce attacker-controlled signing keys with valid
// self-signatures.
let Some(notary_signatures) = incoming.parsed.signatures.get(notary_name) else {
let Some(notary_signatures) = server_keys.signatures.get(notary_name) else {
return Err!(Request(Forbidden(
"Missing notary server signature from {notary_name}"
)));
};
// The notary signed the response as the origin served it, so verify
// over the raw JSON, not a re-serialised `ServerSigningKeys`.
let mut canonical_object = to_canonical_object(notary_signatures)?;
Self::strip_extraneous_signatures(&mut canonical_object, &server_keys.server_name, &[
notary_name,
]);
let for_verify = ruma::signatures::to_canonical_json_string_for_signing(
&to_canonical_object(&incoming.raw)?,
)?;
&to_canonical_object(server_keys).expect("server keys object must be canonical json"),
)
.expect("canonical JSON must be stringable");
let raw_notary_keys = notary_keys.iter().map(Base64::as_bytes).collect::<Vec<_>>();
let raw_notary_signatures = notary_signatures
@@ -152,7 +126,7 @@ impl super::Service {
trace!(
"Valid signature from {notary_name} present on signing keys response \
for {}",
incoming.parsed.server_name
server_keys.server_name
);
return Ok(());
}
@@ -207,9 +181,9 @@ mod tests {
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
)).map(Raw::from_json).unwrap();
Service::verify_server_keys_response(&response_data, None)
Service::verify_server_keys_response(&response_data.deserialize().unwrap(), None)
.expect("Self-signature of real key response is valid");
}
@@ -234,9 +208,9 @@ mod tests {
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
)).map(Raw::from_json).unwrap();
Service::verify_server_keys_response(&response_data, None)
Service::verify_server_keys_response(&response_data.deserialize().unwrap(), None)
.expect("Self-signature of real key response is valid");
}
@@ -261,11 +235,11 @@ mod tests {
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
)).map(Raw::from_json).unwrap();
let starstruck_pubkey =
Base64::<Standard>::parse("Z4oHuEjdUbtC5W/z/gzc5B8raxNk+8gGwbNwgxHqW8Y").unwrap();
Service::verify_server_keys_response(
&response_data,
&response_data.deserialize().unwrap(),
Some((server_name!("starstruck.systems"), &[starstruck_pubkey])),
)
.expect("Server keys from notary are valid");
@@ -291,8 +265,8 @@ mod tests {
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
Service::verify_server_keys_response(&response_data, None)
)).map(Raw::from_json).unwrap();
Service::verify_server_keys_response(&response_data.deserialize().unwrap(), None)
.expect_err("Tampered response should fail self-signature check");
}
@@ -329,45 +303,8 @@ mod tests {
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
Service::verify_server_keys_response(&response_data, None)
)).map(Raw::from_json).unwrap();
Service::verify_server_keys_response(&response_data.deserialize().unwrap(), None)
.expect_err("Intercepted notary response should fail strict validation");
}
#[test]
fn verify_response_with_extra_fields() {
let response_data = serde_json::from_value(serde_json::json!(
{
"old_verify_keys": {},
"server_name": "origin.example",
"signatures": {
"notary.example": {
"ed25519:a_RBdc": "ozlc2T5TlUa9XAsmeam+ESr20573vqFJvYHonj3nG8x+m6v7K5TSlEKTAlTRrJYiC6T/aWB+yxMae6FYR6nqCA"
},
"origin.example": {
"ed25519:a_jUhC": "+8xKspAfqI8SfrioOVliQ/jCPRDZEuag6JfkN5dXx9gsCX2rSnbvVTJlTJXFiDYUSyIJZg8ilq1QaPsT85ltBA"
}
},
"tls_fingerprints": [],
"valid_until_ts": 1900000000000_i64,
"verify_keys": {
"ed25519:a_jUhC": {
"key": "idcPtcSpRB5Chnlv1azhL3rMlcTawgQhoGNZWKaNFGI"
}
}
}
)).map(Raw::from_json).unwrap().try_into().unwrap();
let notary_pubkey =
Base64::<Standard>::parse("0ocHGigwa/ap6gSZzzspDQhhOkVkloaf9apolOvwqo8").unwrap();
Service::verify_server_keys_response(&response_data, None)
.expect("Self-signature must verify over the raw response");
Service::verify_server_keys_response(
&response_data,
Some((server_name!("notary.example"), &[notary_pubkey])),
)
.expect("Notary signature must verify over the raw response");
}
}
+1
View File
@@ -99,6 +99,7 @@ impl Services {
metadata: build!(rooms::metadata::Service),
outlier: build!(rooms::outlier::Service),
pdu_metadata: build!(rooms::pdu_metadata::Service),
queue: build!(rooms::queue::Service),
read_receipt: build!(rooms::read_receipt::Service),
search: build!(rooms::search::Service),
short: build!(rooms::short::Service),