Compare commits

..
Author SHA1 Message Date
Renovate Bot 60f96afa72 chore(deps): update ruma digest to e38e036 2026-11-18 05:05:19 +00:00
12 changed files with 88 additions and 219 deletions

No files matched your search

Generated
+2 -9
View File
@@ -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
View File
@@ -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
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 @@
Fix remote server key signature verification when extra fields exist. Contributed by @hexchen
+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,
+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;
}
+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");
}
}