use std::{collections::BTreeMap, fmt};
use ruma_common::{serde::Base64, OwnedDeviceId, OwnedTransactionId};
use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use serde_json::Value as JsonValue;
use super::{
HashAlgorithm, KeyAgreementProtocol, MessageAuthenticationCode, ShortAuthenticationString,
};
use crate::relation::Reference;
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[ruma_event(type = "m.key.verification.start", kind = ToDevice)]
pub struct ToDeviceKeyVerificationStartEventContent {
pub from_device: OwnedDeviceId,
pub transaction_id: OwnedTransactionId,
#[serde(flatten)]
pub method: StartMethod,
}
impl ToDeviceKeyVerificationStartEventContent {
pub fn new(
from_device: OwnedDeviceId,
transaction_id: OwnedTransactionId,
method: StartMethod,
) -> Self {
Self { from_device, transaction_id, method }
}
}
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[ruma_event(type = "m.key.verification.start", kind = MessageLike)]
pub struct KeyVerificationStartEventContent {
pub from_device: OwnedDeviceId,
#[serde(flatten)]
pub method: StartMethod,
#[serde(rename = "m.relates_to")]
pub relates_to: Reference,
}
impl KeyVerificationStartEventContent {
pub fn new(from_device: OwnedDeviceId, method: StartMethod, relates_to: Reference) -> Self {
Self { from_device, method, relates_to }
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(untagged)]
pub enum StartMethod {
SasV1(SasV1Content),
ReciprocateV1(ReciprocateV1Content),
#[doc(hidden)]
_Custom(_CustomContent),
}
#[doc(hidden)]
#[derive(Clone, Debug, Deserialize, Serialize)]
#[allow(clippy::exhaustive_structs)]
pub struct _CustomContent {
pub method: String,
#[serde(flatten)]
pub data: BTreeMap<String, JsonValue>,
}
#[derive(Clone, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(rename = "m.reciprocate.v1", tag = "method")]
pub struct ReciprocateV1Content {
pub secret: Base64,
}
impl ReciprocateV1Content {
pub fn new(secret: Base64) -> Self {
Self { secret }
}
}
impl fmt::Debug for ReciprocateV1Content {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ReciprocateV1Content").finish_non_exhaustive()
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(rename = "m.sas.v1", tag = "method")]
pub struct SasV1Content {
pub key_agreement_protocols: Vec<KeyAgreementProtocol>,
pub hashes: Vec<HashAlgorithm>,
pub message_authentication_codes: Vec<MessageAuthenticationCode>,
pub short_authentication_string: Vec<ShortAuthenticationString>,
}
#[derive(Debug)]
#[allow(clippy::exhaustive_structs)]
pub struct SasV1ContentInit {
pub key_agreement_protocols: Vec<KeyAgreementProtocol>,
pub hashes: Vec<HashAlgorithm>,
pub message_authentication_codes: Vec<MessageAuthenticationCode>,
pub short_authentication_string: Vec<ShortAuthenticationString>,
}
impl From<SasV1ContentInit> for SasV1Content {
fn from(init: SasV1ContentInit) -> Self {
Self {
key_agreement_protocols: init.key_agreement_protocols,
hashes: init.hashes,
message_authentication_codes: init.message_authentication_codes,
short_authentication_string: init.short_authentication_string,
}
}
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use assert_matches2::assert_matches;
use ruma_common::{event_id, serde::Base64};
use serde_json::{
from_value as from_json_value, json, to_value as to_json_value, Value as JsonValue,
};
use super::{
HashAlgorithm, KeyAgreementProtocol, KeyVerificationStartEventContent,
MessageAuthenticationCode, ReciprocateV1Content, SasV1ContentInit,
ShortAuthenticationString, StartMethod, ToDeviceKeyVerificationStartEventContent,
_CustomContent,
};
use crate::{relation::Reference, ToDeviceEvent};
#[test]
fn serialization() {
let key_verification_start_content = ToDeviceKeyVerificationStartEventContent {
from_device: "123".into(),
transaction_id: "456".into(),
method: StartMethod::SasV1(
SasV1ContentInit {
hashes: vec![HashAlgorithm::Sha256],
key_agreement_protocols: vec![KeyAgreementProtocol::Curve25519],
message_authentication_codes: vec![MessageAuthenticationCode::HkdfHmacSha256V2],
short_authentication_string: vec![ShortAuthenticationString::Decimal],
}
.into(),
),
};
let json_data = json!({
"from_device": "123",
"transaction_id": "456",
"method": "m.sas.v1",
"key_agreement_protocols": ["curve25519"],
"hashes": ["sha256"],
"message_authentication_codes": ["hkdf-hmac-sha256.v2"],
"short_authentication_string": ["decimal"]
});
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
let json_data = json!({
"from_device": "123",
"transaction_id": "456",
"method": "m.sas.custom",
"test": "field",
});
let key_verification_start_content = ToDeviceKeyVerificationStartEventContent {
from_device: "123".into(),
transaction_id: "456".into(),
method: StartMethod::_Custom(_CustomContent {
method: "m.sas.custom".to_owned(),
data: vec![("test".to_owned(), JsonValue::from("field"))]
.into_iter()
.collect::<BTreeMap<String, JsonValue>>(),
}),
};
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
{
let secret = Base64::new(b"This is a secret to everybody".to_vec());
let key_verification_start_content = ToDeviceKeyVerificationStartEventContent {
from_device: "123".into(),
transaction_id: "456".into(),
method: StartMethod::ReciprocateV1(ReciprocateV1Content::new(secret.clone())),
};
let json_data = json!({
"from_device": "123",
"method": "m.reciprocate.v1",
"secret": secret,
"transaction_id": "456"
});
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
}
}
#[test]
fn in_room_serialization() {
let event_id = event_id!("$1598361704261elfgc:localhost");
let key_verification_start_content = KeyVerificationStartEventContent {
from_device: "123".into(),
relates_to: Reference { event_id: event_id.to_owned() },
method: StartMethod::SasV1(
SasV1ContentInit {
hashes: vec![HashAlgorithm::Sha256],
key_agreement_protocols: vec![KeyAgreementProtocol::Curve25519],
message_authentication_codes: vec![MessageAuthenticationCode::HkdfHmacSha256V2],
short_authentication_string: vec![ShortAuthenticationString::Decimal],
}
.into(),
),
};
let json_data = json!({
"from_device": "123",
"method": "m.sas.v1",
"key_agreement_protocols": ["curve25519"],
"hashes": ["sha256"],
"message_authentication_codes": ["hkdf-hmac-sha256.v2"],
"short_authentication_string": ["decimal"],
"m.relates_to": {
"rel_type": "m.reference",
"event_id": event_id,
}
});
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
let secret = Base64::new(b"This is a secret to everybody".to_vec());
let key_verification_start_content = KeyVerificationStartEventContent {
from_device: "123".into(),
relates_to: Reference { event_id: event_id.to_owned() },
method: StartMethod::ReciprocateV1(ReciprocateV1Content::new(secret.clone())),
};
let json_data = json!({
"from_device": "123",
"method": "m.reciprocate.v1",
"secret": secret,
"m.relates_to": {
"rel_type": "m.reference",
"event_id": event_id,
}
});
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
}
#[test]
fn deserialization() {
let json = json!({
"from_device": "123",
"transaction_id": "456",
"method": "m.sas.v1",
"hashes": ["sha256"],
"key_agreement_protocols": ["curve25519"],
"message_authentication_codes": ["hkdf-hmac-sha256.v2"],
"short_authentication_string": ["decimal"]
});
let content = from_json_value::<ToDeviceKeyVerificationStartEventContent>(json).unwrap();
assert_eq!(content.from_device, "123");
assert_eq!(content.transaction_id, "456");
assert_matches!(content.method, StartMethod::SasV1(sas));
assert_eq!(sas.hashes, vec![HashAlgorithm::Sha256]);
assert_eq!(sas.key_agreement_protocols, vec![KeyAgreementProtocol::Curve25519]);
assert_eq!(
sas.message_authentication_codes,
vec![MessageAuthenticationCode::HkdfHmacSha256V2]
);
assert_eq!(sas.short_authentication_string, vec![ShortAuthenticationString::Decimal]);
let json = json!({
"content": {
"from_device": "123",
"transaction_id": "456",
"method": "m.sas.v1",
"key_agreement_protocols": ["curve25519"],
"hashes": ["sha256"],
"message_authentication_codes": ["hkdf-hmac-sha256.v2"],
"short_authentication_string": ["decimal"]
},
"type": "m.key.verification.start",
"sender": "@example:localhost",
});
let ev = from_json_value::<ToDeviceEvent<ToDeviceKeyVerificationStartEventContent>>(json)
.unwrap();
assert_eq!(ev.sender, "@example:localhost");
assert_eq!(ev.content.from_device, "123");
assert_eq!(ev.content.transaction_id, "456");
assert_matches!(ev.content.method, StartMethod::SasV1(sas));
assert_eq!(sas.hashes, vec![HashAlgorithm::Sha256]);
assert_eq!(sas.key_agreement_protocols, vec![KeyAgreementProtocol::Curve25519]);
assert_eq!(
sas.message_authentication_codes,
vec![MessageAuthenticationCode::HkdfHmacSha256V2]
);
assert_eq!(sas.short_authentication_string, vec![ShortAuthenticationString::Decimal]);
let json = json!({
"content": {
"from_device": "123",
"transaction_id": "456",
"method": "m.sas.custom",
"test": "field",
},
"type": "m.key.verification.start",
"sender": "@example:localhost",
});
let ev = from_json_value::<ToDeviceEvent<ToDeviceKeyVerificationStartEventContent>>(json)
.unwrap();
assert_eq!(ev.sender, "@example:localhost");
assert_eq!(ev.content.from_device, "123");
assert_eq!(ev.content.transaction_id, "456");
assert_matches!(ev.content.method, StartMethod::_Custom(custom));
assert_eq!(custom.method, "m.sas.custom");
assert_eq!(custom.data.get("test"), Some(&JsonValue::from("field")));
let json = json!({
"content": {
"from_device": "123",
"method": "m.reciprocate.v1",
"secret": "c2VjcmV0Cg",
"transaction_id": "456",
},
"type": "m.key.verification.start",
"sender": "@example:localhost",
});
let ev = from_json_value::<ToDeviceEvent<ToDeviceKeyVerificationStartEventContent>>(json)
.unwrap();
assert_eq!(ev.sender, "@example:localhost");
assert_eq!(ev.content.from_device, "123");
assert_eq!(ev.content.transaction_id, "456");
assert_matches!(ev.content.method, StartMethod::ReciprocateV1(reciprocate));
assert_eq!(reciprocate.secret.encode(), "c2VjcmV0Cg");
}
#[test]
fn in_room_deserialization() {
let json = json!({
"from_device": "123",
"method": "m.sas.v1",
"hashes": ["sha256"],
"key_agreement_protocols": ["curve25519"],
"message_authentication_codes": ["hkdf-hmac-sha256.v2"],
"short_authentication_string": ["decimal"],
"m.relates_to": {
"rel_type": "m.reference",
"event_id": "$1598361704261elfgc:localhost",
}
});
let content = from_json_value::<KeyVerificationStartEventContent>(json).unwrap();
assert_eq!(content.from_device, "123");
assert_eq!(content.relates_to.event_id, "$1598361704261elfgc:localhost");
assert_matches!(content.method, StartMethod::SasV1(sas));
assert_eq!(sas.hashes, vec![HashAlgorithm::Sha256]);
assert_eq!(sas.key_agreement_protocols, vec![KeyAgreementProtocol::Curve25519]);
assert_eq!(
sas.message_authentication_codes,
vec![MessageAuthenticationCode::HkdfHmacSha256V2]
);
assert_eq!(sas.short_authentication_string, vec![ShortAuthenticationString::Decimal]);
let json = json!({
"from_device": "123",
"method": "m.reciprocate.v1",
"secret": "c2VjcmV0Cg",
"m.relates_to": {
"rel_type": "m.reference",
"event_id": "$1598361704261elfgc:localhost",
}
});
let content = from_json_value::<KeyVerificationStartEventContent>(json).unwrap();
assert_eq!(content.from_device, "123");
assert_eq!(content.relates_to.event_id, "$1598361704261elfgc:localhost");
assert_matches!(content.method, StartMethod::ReciprocateV1(reciprocate));
assert_eq!(reciprocate.secret.encode(), "c2VjcmV0Cg");
}
}