mirror of
https://forgejo.ellis.link/continuwuation/continuwuity.git
synced 2026-11-22 16:37:32 +00:00
302 lines
9.0 KiB
Rust
302 lines
9.0 KiB
Rust
mod get;
|
|
mod keypair;
|
|
mod request;
|
|
mod sign;
|
|
mod util;
|
|
mod verify;
|
|
|
|
use std::{
|
|
collections::{BTreeMap, HashMap},
|
|
sync::Arc,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use assign::assign;
|
|
use async_trait::async_trait;
|
|
use conduwuit::{
|
|
Result, Server, SyncRwLock,
|
|
utils::{IterStream, ReadyExt, stream::TryIgnore, timepoint_from_now, to_canonical_object},
|
|
};
|
|
use database::{Deserialized, Ignore, Interfix, Json, Map};
|
|
use futures::{Stream, StreamExt};
|
|
pub use request::in_one_week;
|
|
use ruma::{
|
|
CanonicalJsonObject, MilliSecondsSinceUnixEpoch, OwnedServerName, OwnedServerSigningKeyId,
|
|
ServerName, ServerSigningKeyId,
|
|
api::federation::discovery::{OldVerifyKey, ServerSigningKeys, VerifyKey},
|
|
room_version_rules::RoomVersionRules,
|
|
serde::Raw,
|
|
signatures::{Ed25519KeyPair, PublicKeyMap, PublicKeySet},
|
|
};
|
|
use serde_json::value::to_raw_value;
|
|
pub use verify::strip_extraneous_signatures;
|
|
|
|
use crate::{Dep, globals, sending, server_keys::util::required_keys};
|
|
|
|
const VALID_UNTIL_TS_DURATION: Duration = Duration::from_hours(12);
|
|
|
|
pub struct Service {
|
|
keypair: Box<Ed25519KeyPair>,
|
|
verify_keys: VerifyKeys,
|
|
services: Services,
|
|
db: Data,
|
|
last_lookup: SyncRwLock<HashMap<OwnedServerName, Instant>>,
|
|
}
|
|
|
|
struct Services {
|
|
globals: Dep<globals::Service>,
|
|
sending: Dep<sending::Service>,
|
|
server: Arc<Server>,
|
|
}
|
|
|
|
struct Data {
|
|
servernamekeyid_response: Arc<Map>,
|
|
}
|
|
|
|
pub type VerifyKeys = BTreeMap<OwnedServerSigningKeyId, VerifyKey>;
|
|
pub type PubKeyMap = PublicKeyMap;
|
|
pub type PubKeys = PublicKeySet;
|
|
|
|
#[async_trait]
|
|
impl crate::Service for Service {
|
|
fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
|
|
let (keypair, verify_keys) = keypair::init(args.db)?;
|
|
debug_assert!(verify_keys.len() == 1, "only one active verify_key supported");
|
|
|
|
Ok(Arc::new(Self {
|
|
keypair,
|
|
verify_keys,
|
|
services: Services {
|
|
globals: args.depend::<globals::Service>("globals"),
|
|
sending: args.depend::<sending::Service>("sending"),
|
|
server: args.server.clone(),
|
|
},
|
|
db: Data {
|
|
servernamekeyid_response: args.db["servernamekeyid_response"].clone(),
|
|
},
|
|
last_lookup: SyncRwLock::new(HashMap::new()),
|
|
}))
|
|
}
|
|
|
|
async fn clear_cache(&self) { self.last_lookup.write().clear(); }
|
|
|
|
fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
|
|
}
|
|
|
|
impl Service {
|
|
/// Fetches the server's active keypair.
|
|
pub fn keypair(&self) -> &Ed25519KeyPair { &self.keypair }
|
|
|
|
/// Fetches the server's active signing key. Panics if there's more than 1
|
|
/// active key.
|
|
pub fn active_verify_key(&self) -> (OwnedServerSigningKeyId, VerifyKey) {
|
|
debug_assert!(self.verify_keys.len() <= 1, "more than one active verify_key");
|
|
self.verify_keys
|
|
.iter()
|
|
.next()
|
|
.map(|(id, key)| (id.to_owned(), key.to_owned()))
|
|
.expect("missing active verify_key")
|
|
}
|
|
|
|
/// Adds a signing key response to the database.
|
|
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
|
|
.verify_keys
|
|
.keys()
|
|
.chain(new_keys.old_verify_keys.keys())
|
|
{
|
|
let db_key = (new_keys.server_name.as_str(), key.as_str());
|
|
self.db.servernamekeyid_response.put(db_key, Json(new_keys));
|
|
}
|
|
}
|
|
|
|
/// Checks if the keys required to verify an incoming PDU are already known
|
|
/// locally.
|
|
pub async fn required_keys_exist(
|
|
&self,
|
|
object: &CanonicalJsonObject,
|
|
room_version_rules: &RoomVersionRules,
|
|
) -> bool {
|
|
let Ok(required_keys) = required_keys(object, &room_version_rules.signatures) else {
|
|
return false;
|
|
};
|
|
let Ok(min_valid_ts) = Self::min_valid_ts_from_event(object) else {
|
|
return false;
|
|
};
|
|
required_keys
|
|
.iter()
|
|
.flat_map(|(server, key_ids)| key_ids.iter().map(move |key_id| (server, key_id)))
|
|
.stream()
|
|
.all(|(server, key_id)| self.verify_key_exists(server, key_id, min_valid_ts))
|
|
.await
|
|
}
|
|
|
|
/// Checks if a single verify key belonging to the target server is already
|
|
/// known locally.
|
|
pub async fn verify_key_exists(
|
|
&self,
|
|
origin: &ServerName,
|
|
key_id: &ServerSigningKeyId,
|
|
minimum_valid_ts: MilliSecondsSinceUnixEpoch,
|
|
) -> bool {
|
|
let Some(keys) = self.get_signing_key(origin, key_id).await else {
|
|
// We have no keys for this server
|
|
return false;
|
|
};
|
|
|
|
if keys.valid_until_ts < minimum_valid_ts || keys.valid_until_ts > in_one_week() {
|
|
// This key response is stale and cannot be trusted.
|
|
return false;
|
|
}
|
|
|
|
if keys.verify_keys.contains_key(key_id) {
|
|
// An in-date, active key exists for this server.
|
|
return true;
|
|
}
|
|
|
|
if let Some(expired_key) = keys.old_verify_keys.get(key_id) {
|
|
// This key can still be used to verify signatures provided it
|
|
// expired within the minimum valid time window.
|
|
return expired_key.expired_ts.min(keys.valid_until_ts) >= minimum_valid_ts;
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
pub async fn get_signing_key(
|
|
&self,
|
|
origin: &ServerName,
|
|
key_id: &ServerSigningKeyId,
|
|
) -> Option<ServerSigningKeys> {
|
|
self.db
|
|
.servernamekeyid_response
|
|
.qry(&(origin.as_str(), key_id.as_str()))
|
|
.await
|
|
.deserialized::<ServerSigningKeys>()
|
|
.ok()
|
|
}
|
|
|
|
/// Returns all (active) verify keys for the origin.
|
|
pub async fn verify_keys_for(&self, origin: &ServerName) -> VerifyKeys {
|
|
let mut keys = self
|
|
.signing_keys_for(origin)
|
|
.ready_fold(BTreeMap::new(), |mut base, keys| {
|
|
base.extend(keys.verify_keys);
|
|
base
|
|
})
|
|
.await;
|
|
|
|
if self.services.globals.server_is_ours(origin) {
|
|
keys.extend(self.verify_keys.clone());
|
|
}
|
|
|
|
keys
|
|
}
|
|
|
|
/// Returns the stored server signing keys responses for the origin.
|
|
///
|
|
/// Does not imply that the stored responses are still in-date.
|
|
pub fn signing_keys_for<'a>(
|
|
&'a self,
|
|
origin: &'a ServerName,
|
|
) -> impl Stream<Item = ServerSigningKeys> + Send + 'a {
|
|
self.db
|
|
.servernamekeyid_response
|
|
.stream_prefix(&(origin, Interfix))
|
|
.ignore_err()
|
|
.map(|(_, v): (Ignore, ServerSigningKeys)| v)
|
|
}
|
|
|
|
/// Determines if the server may contact the origin server to fetch keys
|
|
/// when acting as a notary server. This limits origin lookups to once per
|
|
/// minute, which prevents amplification attacks.
|
|
#[must_use]
|
|
pub fn notary_may_contact_origin(&self, server_name: &ServerName) -> bool {
|
|
if server_name == self.services.server.name {
|
|
// We always intercept origin requests to us with
|
|
// build_server_keys_response, so this is equivalent to
|
|
// calling `/_matrix/key/v2/server`.
|
|
return true;
|
|
}
|
|
self.last_lookup
|
|
.read()
|
|
.get(server_name)
|
|
.is_none_or(|last| last.elapsed() >= Duration::from_mins(1))
|
|
}
|
|
|
|
/// Generates a signing key response to serve to `/_matrix/key/v2/server`.
|
|
pub async fn build_server_keys_response(&self) -> Result<Raw<ServerSigningKeys>> {
|
|
let verify_keys = BTreeMap::from([self.active_verify_key()]);
|
|
let old_verify_keys = match &self.services.server.config.old_verify_keys {
|
|
| Some(old_verify_keys) => old_verify_keys.to_owned(),
|
|
| None => self.discover_old_signing_keys().await,
|
|
};
|
|
let valid_until_ts = timepoint_from_now(VALID_UNTIL_TS_DURATION)
|
|
.map(|tp| {
|
|
MilliSecondsSinceUnixEpoch::from_system_time(tp)
|
|
.expect("key validity period must be before the heat death of the universe")
|
|
})
|
|
.expect("key validity period must be before the heat death of the universe");
|
|
let server_keys = assign!(
|
|
ServerSigningKeys::new(self.services.server.name.clone(), valid_until_ts),
|
|
{verify_keys, old_verify_keys}
|
|
);
|
|
let mut canonical_obj = to_canonical_object(&server_keys)?;
|
|
self.sign_json(&mut canonical_obj)
|
|
.and_then(|()| to_raw_value(&canonical_obj).map_err(Into::into))
|
|
.map(Raw::from_json)
|
|
}
|
|
|
|
async fn discover_old_signing_keys(&self) -> BTreeMap<OwnedServerSigningKeyId, OldVerifyKey> {
|
|
let now = MilliSecondsSinceUnixEpoch::now();
|
|
let mut keys = self.signing_keys_for(&self.services.server.name);
|
|
let mut old_keys = BTreeMap::new();
|
|
while let Some(resp) = keys.next().await {
|
|
// 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.valid_until_ts > in_one_week() || resp.valid_until_ts < now {
|
|
continue;
|
|
}
|
|
let trusted = self
|
|
.services
|
|
.server
|
|
.config
|
|
.trusted_servers
|
|
.iter()
|
|
.any(|notary| {
|
|
Self::verify_server_keys_response(
|
|
&resp,
|
|
Some((notary.server_name(), notary.verify_keys())),
|
|
)
|
|
.is_ok()
|
|
});
|
|
if !trusted {
|
|
continue;
|
|
}
|
|
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;
|
|
}
|
|
old_keys
|
|
.entry(old_key_id)
|
|
.and_modify(|current_old_key: &mut OldVerifyKey| {
|
|
// Use the lowest expiry timestamp
|
|
if current_old_key.expired_ts < old_key.expired_ts {
|
|
*current_old_key = old_key.clone();
|
|
}
|
|
})
|
|
.or_insert(old_key);
|
|
}
|
|
}
|
|
|
|
old_keys
|
|
}
|
|
}
|