mirror of
https://forgejo.ellis.link/continuwuation/continuwuity.git
synced 2026-11-19 15:07:33 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
60f96afa72 |
No files matched your search
Generated
+2
-9
@@ -624,12 +624,6 @@ dependencies = [
|
||||
"pkg-config",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cache_control"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1bf2a5fb3207c12b5d208ebc145f967fea5cac41a021c37417ccc31ba40f39ee"
|
||||
|
||||
[[package]]
|
||||
name = "camino"
|
||||
version = "1.2.6"
|
||||
@@ -4904,11 +4898,10 @@ checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
|
||||
|
||||
[[package]]
|
||||
name = "resolvematrix"
|
||||
version = "1.5.0"
|
||||
version = "1.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "39a1efc3c55274528f8b1a916eb0edf5c40a8364b4899fbc1283a57c8d0024db"
|
||||
checksum = "d6e659fe17ed82acfac43641d00d1bbfd0a9d53ec4d2f901b01f792f0e2c9e3c"
|
||||
dependencies = [
|
||||
"cache_control",
|
||||
"hickory-resolver",
|
||||
"num-traits",
|
||||
"parking_lot",
|
||||
|
||||
+2
-2
@@ -360,7 +360,7 @@ version = "1.1.1"
|
||||
# Used for matrix spec type definitions and helpers
|
||||
[workspace.dependencies.ruma]
|
||||
git = "https://github.com/ruma/ruma.git"
|
||||
rev = "472a23ef86bc0bb40a22d856fc0af539eb9d71b7"
|
||||
rev = "e38e0362155c075ce3a73c163fba8c4ed98ac77e"
|
||||
features = [
|
||||
"appservice-api-c",
|
||||
"client-api",
|
||||
@@ -603,7 +603,7 @@ features = ["std"]
|
||||
version = "0.3.0"
|
||||
|
||||
[workspace.dependencies.resolvematrix]
|
||||
version = "1.5.0"
|
||||
version = "1.4.2"
|
||||
features = ["unstable-msc4188"]
|
||||
|
||||
[workspace.dependencies.serde_urlencoded]
|
||||
|
||||
+3
-17
@@ -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 +0,0 @@
|
||||
Fix remote server key signature verification when extra fields exist. Contributed by @hexchen
|
||||
@@ -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}
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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:?}"
|
||||
);
|
||||
})
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user