use std::{borrow::Cow, collections::BTreeMap};
use js_int::UInt;
use ruma_common::{serde::JsonObject, OwnedDeviceId, OwnedEventId};
use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use super::message;
use crate::relation::{Annotation, CustomRelation, InReplyTo, Reference, RelationType, Thread};
mod relation_serde;
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[ruma_event(type = "m.room.encrypted", kind = MessageLike)]
pub struct RoomEncryptedEventContent {
#[serde(flatten)]
pub scheme: EncryptedEventScheme,
#[serde(rename = "m.relates_to", skip_serializing_if = "Option::is_none")]
pub relates_to: Option<Relation>,
}
impl RoomEncryptedEventContent {
pub fn new(scheme: EncryptedEventScheme, relates_to: Option<Relation>) -> Self {
Self { scheme, relates_to }
}
}
impl From<EncryptedEventScheme> for RoomEncryptedEventContent {
fn from(scheme: EncryptedEventScheme) -> Self {
Self { scheme, relates_to: None }
}
}
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[ruma_event(type = "m.room.encrypted", kind = ToDevice)]
pub struct ToDeviceRoomEncryptedEventContent {
#[serde(flatten)]
pub scheme: EncryptedEventScheme,
}
impl ToDeviceRoomEncryptedEventContent {
pub fn new(scheme: EncryptedEventScheme) -> Self {
Self { scheme }
}
}
impl From<EncryptedEventScheme> for ToDeviceRoomEncryptedEventContent {
fn from(scheme: EncryptedEventScheme) -> Self {
Self { scheme }
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(tag = "algorithm")]
pub enum EncryptedEventScheme {
#[serde(rename = "m.olm.v1.curve25519-aes-sha2")]
OlmV1Curve25519AesSha2(OlmV1Curve25519AesSha2Content),
#[serde(rename = "m.megolm.v1.aes-sha2")]
MegolmV1AesSha2(MegolmV1AesSha2Content),
}
#[derive(Clone, Debug)]
#[allow(clippy::manual_non_exhaustive)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
pub enum Relation {
Reply {
in_reply_to: InReplyTo,
},
Replacement(Replacement),
Reference(Reference),
Annotation(Annotation),
Thread(Thread),
#[doc(hidden)]
_Custom(CustomRelation),
}
impl Relation {
pub fn rel_type(&self) -> Option<RelationType> {
match self {
Relation::Reply { .. } => None,
Relation::Replacement(_) => Some(RelationType::Replacement),
Relation::Reference(_) => Some(RelationType::Reference),
Relation::Annotation(_) => Some(RelationType::Annotation),
Relation::Thread(_) => Some(RelationType::Thread),
Relation::_Custom(c) => c.rel_type(),
}
}
pub fn data(&self) -> Cow<'_, JsonObject> {
if let Relation::_Custom(CustomRelation(data)) = self {
Cow::Borrowed(data)
} else {
Cow::Owned(self.serialize_data())
}
}
}
impl<C> From<message::Relation<C>> for Relation {
fn from(rel: message::Relation<C>) -> Self {
match rel {
message::Relation::Reply { in_reply_to } => Self::Reply { in_reply_to },
message::Relation::Replacement(re) => {
Self::Replacement(Replacement { event_id: re.event_id })
}
message::Relation::Thread(t) => Self::Thread(Thread {
event_id: t.event_id,
in_reply_to: t.in_reply_to,
is_falling_back: t.is_falling_back,
}),
message::Relation::_Custom(c) => Self::_Custom(c),
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(tag = "rel_type", rename = "m.replace")]
pub struct Replacement {
pub event_id: OwnedEventId,
}
impl Replacement {
pub fn new(event_id: OwnedEventId) -> Self {
Self { event_id }
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
pub struct OlmV1Curve25519AesSha2Content {
pub ciphertext: BTreeMap<String, CiphertextInfo>,
pub sender_key: String,
}
impl OlmV1Curve25519AesSha2Content {
pub fn new(ciphertext: BTreeMap<String, CiphertextInfo>, sender_key: String) -> Self {
Self { ciphertext, sender_key }
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
pub struct CiphertextInfo {
pub body: String,
#[serde(rename = "type")]
pub message_type: UInt,
}
impl CiphertextInfo {
pub fn new(body: String, message_type: UInt) -> Self {
Self { body, message_type }
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
pub struct MegolmV1AesSha2Content {
pub ciphertext: String,
#[deprecated = "this field still needs to be sent but should not be used when received"]
pub sender_key: String,
#[deprecated = "this field still needs to be sent but should not be used when received"]
pub device_id: OwnedDeviceId,
pub session_id: String,
}
#[derive(Debug)]
#[allow(clippy::exhaustive_structs)]
pub struct MegolmV1AesSha2ContentInit {
pub ciphertext: String,
pub sender_key: String,
pub device_id: OwnedDeviceId,
pub session_id: String,
}
impl From<MegolmV1AesSha2ContentInit> for MegolmV1AesSha2Content {
fn from(init: MegolmV1AesSha2ContentInit) -> Self {
let MegolmV1AesSha2ContentInit { ciphertext, sender_key, device_id, session_id } = init;
#[allow(deprecated)]
Self { ciphertext, sender_key, device_id, session_id }
}
}
#[cfg(test)]
mod tests {
use assert_matches2::assert_matches;
use js_int::uint;
use ruma_common::{owned_event_id, serde::Raw};
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{
EncryptedEventScheme, InReplyTo, MegolmV1AesSha2ContentInit, Relation,
RoomEncryptedEventContent,
};
#[test]
fn serialization() {
let key_verification_start_content = RoomEncryptedEventContent {
scheme: EncryptedEventScheme::MegolmV1AesSha2(
MegolmV1AesSha2ContentInit {
ciphertext: "ciphertext".into(),
sender_key: "sender_key".into(),
device_id: "device_id".into(),
session_id: "session_id".into(),
}
.into(),
),
relates_to: Some(Relation::Reply {
in_reply_to: InReplyTo { event_id: owned_event_id!("$h29iv0s8:example.com") },
}),
};
let json_data = json!({
"algorithm": "m.megolm.v1.aes-sha2",
"ciphertext": "ciphertext",
"sender_key": "sender_key",
"device_id": "device_id",
"session_id": "session_id",
"m.relates_to": {
"m.in_reply_to": {
"event_id": "$h29iv0s8:example.com"
}
},
});
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
}
#[test]
#[allow(deprecated)]
fn deserialization() {
let json_data = json!({
"algorithm": "m.megolm.v1.aes-sha2",
"ciphertext": "ciphertext",
"sender_key": "sender_key",
"device_id": "device_id",
"session_id": "session_id",
"m.relates_to": {
"m.in_reply_to": {
"event_id": "$h29iv0s8:example.com"
}
},
});
let content: RoomEncryptedEventContent = from_json_value(json_data).unwrap();
assert_matches!(content.scheme, EncryptedEventScheme::MegolmV1AesSha2(scheme));
assert_eq!(scheme.ciphertext, "ciphertext");
assert_eq!(scheme.sender_key, "sender_key");
assert_eq!(scheme.device_id, "device_id");
assert_eq!(scheme.session_id, "session_id");
assert_matches!(content.relates_to, Some(Relation::Reply { in_reply_to }));
assert_eq!(in_reply_to.event_id, "$h29iv0s8:example.com");
}
#[test]
fn deserialization_olm() {
let json_data = json!({
"sender_key": "test_key",
"ciphertext": {
"test_curve_key": {
"body": "encrypted_body",
"type": 1
}
},
"algorithm": "m.olm.v1.curve25519-aes-sha2"
});
let content: RoomEncryptedEventContent = from_json_value(json_data).unwrap();
assert_matches!(content.scheme, EncryptedEventScheme::OlmV1Curve25519AesSha2(c));
assert_eq!(c.sender_key, "test_key");
assert_eq!(c.ciphertext.len(), 1);
assert_eq!(c.ciphertext["test_curve_key"].body, "encrypted_body");
assert_eq!(c.ciphertext["test_curve_key"].message_type, uint!(1));
assert_matches!(content.relates_to, None);
}
#[test]
fn deserialization_failure() {
from_json_value::<Raw<RoomEncryptedEventContent>>(
json!({ "algorithm": "m.megolm.v1.aes-sha2" }),
)
.unwrap()
.deserialize()
.unwrap_err();
}
}