arminius_server_client/handlers/

signatures.rs

// SPDX-FileCopyrightText: 2025 BWI GmbH
//
// SPDX-License-Identifier: Apache-2.0

//! Implements the signature upload endpoint (See
//! <https://spec.matrix.org/v1.16/client-server-api/#post_matrixclientv3keyssignaturesupload>).
//!
//! This endpoint is quite complex in that it requires many checks in order to
//! be done properly. This is why it got its dedicated module.

#![allow(
	clippy::allow_attributes,
	reason = "This source file contains enums which allow `clippy::missing_docs_in_private_items`. But an exception to this lint will mistakenly report that it's unfulfilled when used with expect, even though it is not."
)]

use std::collections::BTreeMap;

use arminius_lib_authentication::SessionInfo;
use arminius_lib_component::{
	Component, ServerState,
	error::{
		BadJson, InputJsonError, InternalServerError, MatrixApiError, ResultExt as _,
		create_custom_matrix_error,
	},
	ruma_requests::ArminiusResponse,
};
use arminius_lib_db::{Database as _, DefaultDb};
use arminius_lib_db_keys::{CrossSigningKeyRow, DeviceKeysRow};
use arminius_lib_db_signatures::LocalSignatureQueries as _;
use arminius_lib_model::user_keys::DbKeyType;
use arminius_lib_user_keys::{
	identity_keys::get_local_keys,
	signatures::{RequiredSigners, SignatureVerificationError, verify_signatures},
	traits::{SignedObject, SigningKey as _},
};
use axum::{Router, extract::State, http::StatusCode, routing::post};
use itertools::Itertools as _;
use ruma::{
	Base64PublicKeyOrDeviceId, OwnedCrossSigningOrDeviceSigningKeyId, OwnedDeviceId, OwnedUserId,
	UserId,
	api::{
		client::keys::upload_signatures,
		error::{Error as MatrixError, ErrorCode, ErrorKind},
	},
	encryption::{CrossSigningKey, DeviceKeys, KeyUsage},
	serde::{Base64, base64},
	signatures::PublicKeyMap,
};

use crate::client_request::AuthenticatedClientRequest;

/// Thrown when a signature is not valid
#[derive(Debug, thiserror::Error)]
#[error("Invalid signature: {0}")]
pub struct SignatureError(String);

// Manually implemented, because `ErrorKind` does not agree with custom error
// codes.
impl MatrixApiError for SignatureError {
	fn create_matrix_error(&self) -> MatrixError {
		create_custom_matrix_error(
			StatusCode::BAD_REQUEST,
			"M_INVALID_SIGNATURE",
			&self.to_string(),
		)
	}
}

/// Converts a [`SignatureVerificationError`] into a [`SignaturesUploadError`]
/// so that it can be returned as Matrix error.
impl From<SignatureVerificationError> for SignaturesUploadError {
	fn from(signature_error: SignatureVerificationError) -> Self {
		match signature_error {
			SignatureVerificationError::BadJson(bad_json) => {
				Self::InputJsonError(InputJsonError::BadJson(bad_json))
			}
			other_error => Self::SignatureVerification(SignatureError(other_error.to_string())),
		}
	}
}

#[allow(
	clippy::missing_docs_in_private_items,
	reason = "TODO(#2003): This exception predates us enabling `clippy::allow_attributes_without_reason`, so we don't know why it was enabled"
)]
#[derive(Debug, thiserror::Error, MatrixApiError)]
enum SignaturesUploadError {
	#[error(transparent)]
	InternalServerError(#[from] InternalServerError),

	#[error(transparent)]
	InputJsonError(#[from] InputJsonError),

	/// Thrown when a signature is not valid base64
	#[error("Invalid base64: {0}")]
	#[matrix_api_error(status_code = StatusCode::BAD_REQUEST, error_kind = ErrorKind::Unknown)]
	InvalidBase64(#[from] ruma::serde::Base64DecodeError),

	#[error(transparent)]
	SignatureVerification(#[from] SignatureError),
}

/// Helper function that generates a [`upload_signatures::v3::Failure`]. These
/// are returned by the `upload_keys_signature` endpoint.
fn new_failure(
	errcode: &ErrorCode,
	message: &str,
) -> Result<upload_signatures::v3::Failure, InternalServerError> {
	serde_json::from_str(&format!("{{\"errcode\":\"{}\",\"error\":\"{}\"}}", errcode, message))
		.unrecoverable_error("Failed to create Failure")
}

/// Map from user ID to a map from key ID (string) to failure.
///
/// This is a subset of what can be returned by the `upload_keys_signature`
/// endpoint.
type Failures = BTreeMap<OwnedUserId, BTreeMap<String, upload_signatures::v3::Failure>>;

/// Since there are three possible signatures being uploaded (See
/// `upload_keys_signature`), we first separate the request's signed objects
/// into the three possible cases, and return a 3-tuple containing the uploaded
/// keys for each cases: (
///		Key ID and signed device keys belonging to the requester,
///		Key ID and Master key for the key owned by the requester,
///		A map from user ID to a map of key ID to cross-signing key
///	)
///
/// This type is returned by [`separate_signatures`].
///
/// NOTE: The "self Master key" is an `Option` because there can only be one.
type SignedKeysList = (
	Vec<(String, DeviceKeys)>,
	Option<(String, CrossSigningKey)>,
	BTreeMap<OwnedUserId, BTreeMap<String, CrossSigningKey>>,
);

/// Contains a signature to be inserted in the database.
#[derive(Debug)]
pub struct ValidSignature {
	/// Type of key that issued the signature.
	pub signing_key_type: DbKeyType,
	/// Key ID of the key that issued the signature.
	pub signing_key_id: OwnedCrossSigningOrDeviceSigningKeyId,
	/// Unique ID of the signed key. References an entry of the `user_keys`
	/// table.
	pub signed_key_nid: i64,
	/// The actual signature.
	pub signature: Vec<u8>,
}

/// Separates the received signed keys into the three cases (See
/// [`SignedKeysList`] and `upload_keys_signature`).
///
/// # Errors
///
/// This function errors if:
/// - The signed object is not a [CrossSigningKey] nor a [DeviceKeys].
/// - The signed key is a device keys that is **not owned** by the requesting user.
/// - The signed key is a cross-signing key but its `usage` field does not contain exactly one
///   entry.
/// - The signed key is a cross-signing key that is **not a Master key**.
fn separate_signatures(
	request_user_id: &UserId,
	signed_keys: &BTreeMap<OwnedUserId, upload_signatures::v3::SignedKeys>,
) -> Result<SignedKeysList, SignaturesUploadError> {
	let mut self_device_keys_signatures = Vec::new();
	let mut self_master_key_signatures = None;
	let mut other_master_key_signatures: BTreeMap<OwnedUserId, BTreeMap<String, CrossSigningKey>> =
		BTreeMap::new();

	for (signed_user_id, user_signed_keys) in signed_keys {
		for (key_id, signed_object) in user_signed_keys {
			let key_id = key_id.to_owned();
			// First, try to deserialize it as `DeviceKeys`
			if let Ok(signed_device_keys) = serde_json::from_str::<DeviceKeys>(signed_object.get())
			{
				if signed_user_id == request_user_id {
					self_device_keys_signatures.push((key_id, signed_device_keys));
				} else {
					return Err(InputJsonError::BadJson(BadJson(
						"Cannot upload device-keys signatures for other users".to_owned(),
					))
					.into());
				}
			}
			// Else, try to deserialize it as a `CrossSigningKey`
			else if let Ok(signed_cross_signing_key) =
				serde_json::from_str::<CrossSigningKey>(signed_object.get())
			{
				let Ok(key_usage) = signed_cross_signing_key.usage.iter().exactly_one() else {
					return Err(InputJsonError::BadJson(BadJson(
						"Cross-signing key `usage` should contain exactly one entry".to_owned(),
					))
					.into());
				};

				if key_usage != &KeyUsage::Master {
					return Err(InputJsonError::BadJson(BadJson(
						"Cannot upload signatures for a cross-signing key that is not a Master key"
							.to_owned(),
					))
					.into());
				}

				// Put it in the correct output vector, based on if it's that of
				// the requester, or someone else's
				if signed_user_id == request_user_id {
					self_master_key_signatures = Some((key_id, signed_cross_signing_key));
				} else {
					let user_keys =
						other_master_key_signatures.entry(signed_user_id.to_owned()).or_default();
					user_keys.insert(key_id, signed_cross_signing_key);
				}
			}
			// Error if its neither of the two
			else {
				return Err(InputJsonError::BadJson(BadJson(
					"Signed objects must be either device keys or cross-signing keys.".to_owned(),
				))
				.into());
			}
		}
	}

	Ok((self_device_keys_signatures, self_master_key_signatures, other_master_key_signatures))
}

/// Checks that a signature uploaded in `upload_keys_signature` is
/// cryptographically correct.
///
/// Returns a [`upload_signatures::v3::Failure`] if they the verification fails.
fn check_signing(
	keymaps: Vec<&PublicKeyMap>,
	signed_key: &impl SignedObject<OwnedUserId, Base64PublicKeyOrDeviceId>,
	required_signers: Option<&RequiredSigners<OwnedUserId, Base64PublicKeyOrDeviceId>>,
) -> Result<Option<upload_signatures::v3::Failure>, SignaturesUploadError> {
	if let Err(err) = verify_signatures(keymaps, signed_key, required_signers) {
		let failure = match err {
			SignatureVerificationError::BadJson(bad_json) => {
				new_failure(&ErrorCode::BadJson, &bad_json.0)?
			}
			other_error => {
				new_failure(&ErrorCode::from("M_INVALID_SIGNATURE"), &other_error.to_string())?
			}
		};

		return Ok(Some(failure));
	}

	Ok(None)
}

/// This function is part of `upload_keys_signature` and processes signatures
/// uploaded for device keys owned by the requester.
///
/// # Failures
///
/// Here are the cases that will produce failures to be returned by the
/// endpoint:
/// - We do not have any stored self-signing key for the user. Such a key is necessary to check the
///   uploaded device signatures (See `upload_keys_signature`).
/// - We do not have the corresponding stored device keys object for an uploaded one (e.g it is not
///   in the database, or the one we have is different).
/// - The actual signature is invalid (See <https://spec.matrix.org/v1.16/appendices/#signing-json>).
#[expect(
	clippy::too_many_lines,
	reason = "It is too soon to factor out common lines with other functions"
)]
fn process_device_keys_signatures(
	signing_user_id: &UserId,
	self_signing_key: Option<&CrossSigningKeyRow>,
	stored_device_keys: &BTreeMap<OwnedDeviceId, DeviceKeysRow>,
	new_device_keys: Vec<(String, DeviceKeys)>,
) -> Result<(Vec<ValidSignature>, Failures), SignaturesUploadError> {
	// Fail if we are missing the self-signing key to verify signatures
	let Some(self_signing_key) = self_signing_key else {
		let failure = new_failure(
			&ErrorCode::BadJson,
			"Missing self-signing key to verify device keys signatures",
		)?;

		let failures = BTreeMap::from([(
			signing_user_id.to_owned(),
			BTreeMap::from_iter(
				new_device_keys.into_iter().map(|(key_id, _key)| (key_id, failure.clone())),
			),
		)]);

		return Ok((Vec::new(), failures));
	};

	let signing_key_id = self_signing_key
		.key
		.key_id()
		.unrecoverable_error("Unable to get key ID from stored self-signing key")?;

	let mut valid_signatures = Vec::new();
	let mut user_failures = BTreeMap::new();

	for (signed_device_keys_id, mut signed_device_keys) in new_device_keys {
		// Fail if we don't have the same device keys stored
		let Some(stored_device_keys) = stored_device_keys.get(&signed_device_keys.device_id) else {
			user_failures.insert(
				signed_device_keys_id,
				new_failure(&ErrorCode::BadJson, "No matching device keys found")?,
			);

			continue;
		};

		// Verify that the uploaded one matches the stored one
		if !stored_device_keys
			.key
			.compare(&signed_device_keys)
			.unrecoverable_error("Failed to compare keys")?
		{
			user_failures.insert(
				signed_device_keys_id,
				new_failure(&ErrorCode::BadJson, "Signed device keys does not match stored one")?,
			);

			continue;
		}

		// Skip it if the stored device keys already contain that signature
		if stored_device_keys
			.key
			.signatures
			.get(signing_user_id)
			.map(|user_signatures| user_signatures.contains_key(&signing_key_id))
			== Some(true)
		{
			continue;
		}

		// Make sure the newly uploaded signature is there and extract it
		let Some(signature) = signed_device_keys
			.signatures
			.get(signing_user_id)
			.and_then(|user_signatures| user_signatures.get(&signing_key_id))
			.cloned()
		else {
			user_failures.insert(
				signed_device_keys_id.clone(),
				new_failure(
					&ErrorCode::BadJson,
					&format!(
						"Device keys '{}' should contain a signature from '{}'",
						signed_device_keys_id, signing_key_id
					),
				)?,
			);

			continue;
		};

		let device_keys_id = stored_device_keys
			.key
			.key_id()
			.unrecoverable_error("Failed to get key ID of stored keys")?;
		if signed_device_keys
			.signatures
			.get(&signed_device_keys.user_id)
			.and_then(|user_sigs| user_sigs.get(&device_keys_id))
			.is_none()
		{
			let self_signature = stored_device_keys
				.key
				.signatures
				.get(&stored_device_keys.key.user_id)
				.and_then(|user_sigs| user_sigs.get(&device_keys_id))
				.unrecoverable_error("We store device keys that are not signed by themselves")?;

			signed_device_keys.signatures.insert_signature(
				signed_device_keys.user_id.clone(),
				device_keys_id,
				self_signature.to_owned(),
			);
		}

		// Verify the signature is actually correct, and that the device keys
		// are signed by both themselves and the self-signing keys
		if let Some(failure) = check_signing(
			vec![
				&self_signing_key.key.keymap().map_err(InputJsonError::BadJson)?,
				&signed_device_keys.keymap().map_err(InputJsonError::BadJson)?,
			],
			&signed_device_keys,
			Some(&BTreeMap::from([(
				signing_user_id.to_owned(),
				vec![signed_device_keys.key_id().map_err(InputJsonError::BadJson)?],
			)])),
		)? {
			user_failures.insert(signed_device_keys_id, failure);
			continue;
		}

		let signature: Vec<u8> = Base64::<base64::Standard>::parse(signature)?.as_bytes().to_vec();

		valid_signatures.push(ValidSignature {
			signing_key_type: DbKeyType::SelfSigning,
			signing_key_id: signing_key_id.clone(),
			signed_key_nid: stored_device_keys.nid,
			signature,
		});
	}

	if !user_failures.is_empty() {
		return Ok((
			valid_signatures,
			BTreeMap::from([(signing_user_id.to_owned(), user_failures)]),
		));
	}

	Ok((valid_signatures, BTreeMap::new()))
}

/// This function is part of `upload_keys_signature` and processes signatures
/// uploaded for the Master key owned by the requester.
///
/// # Failures
///
/// Here are the cases that will produce failures to be returned by the
/// endpoint:
/// - We do not have the corresponding stored Master key (e.g it is not in the database, or the one
///   we have is different).
/// - We do not have the corresponding stored device keys that was used to sign the Master key.
/// - The actual signature is invalid (See <https://spec.matrix.org/v1.16/appendices/#signing-json>).
fn process_self_master_key_signatures(
	session: &SessionInfo,
	device_keys: &BTreeMap<OwnedDeviceId, DeviceKeysRow>,
	stored_master_key: Option<&CrossSigningKeyRow>,
	new_master_key: &CrossSigningKey,
) -> Result<(Option<ValidSignature>, Option<upload_signatures::v3::Failure>), SignaturesUploadError>
{
	// Get the device keys used to sign the master key or fail if not found
	let Some(signing_device_keys) = device_keys.get(&session.device_id) else {
		return Ok((
			None,
			Some(new_failure(&ErrorCode::BadJson, "No device keys found to verify signature")?),
		));
	};

	// Make sure we found the corresponding stored one
	let Some(stored_master_key) = stored_master_key else {
		return Ok((None, Some(new_failure(&ErrorCode::BadJson, "No matching Master key found")?)));
	};

	// Verify the uploaded one matches the stored one
	if !stored_master_key
		.key
		.compare(new_master_key)
		.unrecoverable_error("Failed to compare keys")?
	{
		return Ok((
			None,
			Some(new_failure(&ErrorCode::BadJson, "Signed Master key does not match stored one")?),
		));
	}

	let signing_key_id =
		signing_device_keys.key.key_id().unrecoverable_error("Failed to get key ID")?;

	// Skip that signature if the stored one already has it
	if stored_master_key
		.key
		.signatures
		.get(&session.user_id)
		.map(|user_signatures| user_signatures.contains_key(&signing_key_id))
		== Some(true)
	{
		return Ok((None, None));
	}

	// Make sure the newly uploaded signature is there and extract it
	let Some(signature) = new_master_key
		.signatures
		.get(&session.user_id)
		.and_then(|user_signatures| user_signatures.get(&signing_key_id))
	else {
		return Ok((
			None,
			Some(new_failure(
				&ErrorCode::BadJson,
				"Master key is not signed by the requesting user's device",
			)?),
		));
	};

	// Verify the signature is actually correct
	if let Some(failure) = check_signing(
		vec![&signing_device_keys.key.keymap().map_err(InputJsonError::BadJson)?],
		new_master_key,
		None,
	)? {
		return Ok((None, Some(failure)));
	}

	let signature: Vec<u8> = Base64::<base64::Standard>::parse(signature)?.as_bytes().to_vec();

	Ok((
		Some(ValidSignature {
			signing_key_type: DbKeyType::Device,
			signing_key_id,
			signed_key_nid: stored_master_key.nid,
			signature,
		}),
		None,
	))
}

/// This function is part of `upload_keys_signature` and processes signatures
/// uploaded for Master keys owned by other users.
///
/// # Failures
///
/// Here are the cases that will produce failures to be returned by the
/// endpoint:
/// - We do not have any stored user-signing key for the user. Such a key is necessary to check the
///   uploaded device signatures (See `upload_keys_signature`).
/// - We do not have the corresponding Master key object for an uploaded one (e.g it is not in the
///   database, or the one we have is different).
/// - The actual signature is invalid (See <https://spec.matrix.org/v1.16/appendices/#signing-json>).
fn process_other_master_key_signatures(
	signing_user_id: &UserId,
	user_signing_key: Option<&CrossSigningKeyRow>,
	stored_master_keys: &BTreeMap<OwnedUserId, CrossSigningKeyRow>,
	new_master_keys: &BTreeMap<OwnedUserId, BTreeMap<String, CrossSigningKey>>,
) -> Result<(Vec<ValidSignature>, Failures), SignaturesUploadError> {
	// Fail if we are missing the user-signing key to verify signatures
	let Some(user_signing_key) = user_signing_key else {
		let failure = new_failure(
			&ErrorCode::BadJson,
			"Missing user-signing key to verify other user master key signatures",
		)?;

		let failures = BTreeMap::from_iter(new_master_keys.iter().map(|(user_id, user_keys)| {
			(
				user_id.to_owned(),
				BTreeMap::from_iter(
					user_keys.keys().cloned().map(|key_id| (key_id, failure.clone())),
				),
			)
		}));

		return Ok((Vec::new(), failures));
	};

	let signing_key_id =
		user_signing_key.key.key_id().unrecoverable_error("Failed to get key ID")?;

	let mut valid_signatures = Vec::new();
	let mut failures = BTreeMap::new();

	for (signed_user_id, signed_keys) in new_master_keys {
		// Fail if we don't know the master key of that user
		let Some(stored_master_key) = stored_master_keys.get(signed_user_id) else {
			let failure = new_failure(&ErrorCode::BadJson, "Missing matching master key")?;
			failures.insert(
				signed_user_id.to_owned(),
				BTreeMap::from_iter(
					signed_keys.keys().cloned().map(|key_id| (key_id, failure.clone())),
				),
			);

			continue;
		};

		for (signed_key_id, signed_master_key) in signed_keys {
			// Verify that the uploaded master key matches the stored one
			if !stored_master_key
				.key
				.compare(signed_master_key)
				.unrecoverable_error("Failed to compare keys")?
			{
				failures.insert(
					signed_user_id.to_owned(),
					BTreeMap::from([(
						signed_key_id.to_owned(),
						new_failure(&ErrorCode::BadJson, "Master key does not match stored one")?,
					)]),
				);

				continue;
			}

			// Make sure the newly uploaded signature is there and extract it
			let Some(signature) = signed_master_key
				.signatures
				.get(signing_user_id)
				.and_then(|user_signatures| user_signatures.get(&signing_key_id))
				.cloned()
			else {
				failures.insert(
					signed_user_id.to_owned(),
					BTreeMap::from([(
						signed_key_id.to_owned(),
						new_failure(
							&ErrorCode::BadJson,
							&format!(
								"Master key '{}' is missing a signature from '{}'",
								signed_key_id, signing_key_id
							),
						)?,
					)]),
				);

				continue;
			};

			// Verify the signature is actually correct
			if let Some(failure) = check_signing(
				vec![&user_signing_key.key.keymap().map_err(InputJsonError::BadJson)?],
				signed_master_key,
				None,
			)? {
				failures.insert(
					signed_user_id.to_owned(),
					BTreeMap::from([(signed_key_id.to_owned(), failure)]),
				);

				continue;
			}

			let signature: Vec<u8> =
				Base64::<base64::Standard>::parse(signature)?.as_bytes().to_vec();

			valid_signatures.push(ValidSignature {
				signing_key_type: DbKeyType::UserSigning,
				signing_key_id: signing_key_id.clone(),
				signed_key_nid: stored_master_key.nid,
				signature,
			});
		}
	}

	Ok((valid_signatures, failures))
}

/// Handler for `POST /_matrix/client/v3/keys/signatures/upload` (See
/// <https://spec.matrix.org/v1.16/client-server-api/#post_matrixclientv3keyssignaturesupload>).
///
/// There are 3 possible signatures being uploaded via this endpoint:
/// - Signatures for the user's device keys, emitted by their Self-Signing key
/// - Signature for the user's Master key, emitted by their device keys
/// - Signatures for other users' Master keys, emitted by the requester's User-Signing key
///
/// We therefore split and process each of these three cases separately, and
/// then we return a map from user ID to key ID to an error for any signatures
/// that failed being verified.
async fn upload_signatures_handler(
	mut database: State<DefaultDb>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		upload_signatures::v3::Request,
	>,
) -> Result<ArminiusResponse<upload_signatures::v3::Response>, SignaturesUploadError> {
	// 1. Separate the uploaded signatures into the 3 possible categories
	let (self_device_keys_signatures, self_master_key_signatures, other_users_master_keys) =
		separate_signatures(&claims.user_id, &request.signed_keys)?;

	// 2. Fetch every possibly involved signing keys
	let stored_keys = get_local_keys(
		&mut database,
		Some(&claims.user_id.clone()),
		std::iter::once((claims.user_id.clone(), Vec::new()))
			.chain(
				other_users_master_keys
					.keys()
					.map(|other_user_id| (other_user_id.clone(), Vec::new())),
			)
			.collect(),
	)
	.await?;

	let mut valid_signatures = Vec::new();
	let mut failures = BTreeMap::new();

	// 3. Process device keys signed by the user's self-signing key.
	if !self_device_keys_signatures.is_empty() {
		let (new_valid_signatures, new_failures) = process_device_keys_signatures(
			&claims.user_id,
			stored_keys.self_signing_keys.get(&claims.user_id),
			stored_keys.device_keys.get(&claims.user_id).unwrap_or(&BTreeMap::new()),
			self_device_keys_signatures,
		)?;
		valid_signatures.extend(new_valid_signatures);
		failures.extend(new_failures);
	}

	// 4. Process (if any) the user's Master key signed by their device keys.
	if let Some((signed_master_key_id, signed_master_key)) = self_master_key_signatures {
		let (new_valid_signature, new_invalid_signature) = process_self_master_key_signatures(
			&claims,
			stored_keys.device_keys.get(&claims.user_id).unwrap_or(&BTreeMap::new()),
			stored_keys.master_keys.get(&claims.user_id),
			&signed_master_key,
		)?;

		if let Some(valid_signature) = new_valid_signature {
			valid_signatures.push(valid_signature);
		}
		if let Some(failure) = new_invalid_signature {
			failures
				.insert(claims.user_id.clone(), BTreeMap::from([(signed_master_key_id, failure)]));
		}
	}

	// 5. Process other users Master keys signed by the requester's user-signing key.
	if !other_users_master_keys.is_empty() {
		let (new_valid_signatures, new_failures) = process_other_master_key_signatures(
			&claims.user_id,
			stored_keys.user_signing_keys.get(&claims.user_id),
			&stored_keys.master_keys,
			&other_users_master_keys,
		)?;
		valid_signatures.extend(new_valid_signatures);
		failures.extend(new_failures);
	}

	// 6. Store all the valid signatures
	let mut transaction =
		database.begin_transaction().await.unrecoverable_error("Failed to start transaction")?;
	for ValidSignature { signing_key_type, signing_key_id, signed_key_nid, signature } in
		valid_signatures
	{
		transaction
			.upsert_local_signature(
				&claims.user_id,
				signing_key_type,
				&signing_key_id,
				signed_key_nid,
				&signature,
			)
			.await
			.unrecoverable_error("Failed to insert valid cross-signing signatures")?;
	}
	transaction.commit().await.unrecoverable_error("Failed to commit transaction")?;

	// 7. Return all the failing signatures.
	let mut response = upload_signatures::v3::Response::new();
	response.failures = failures;
	Ok(response.into())
}

/// Component implementing endpoints for signatures.
#[derive(Debug)]
pub struct SignaturesComponent;

impl Component for SignaturesComponent {
	fn router() -> Router<ServerState> {
		Router::new()
			.route("/_matrix/client/v3/keys/signatures/upload", post(upload_signatures_handler))
	}
}