Struct vodozemac::megolm::InboundGroupSession

source ·

pub struct InboundGroupSession { /* private fields */ }

Implementations§

source §

impl InboundGroupSession

source

pub fn new(key: &SessionKey, session_config: SessionConfig) -> Self

source

pub fn import( session_key: &ExportedSessionKey, session_config: SessionConfig ) -> Self

source

pub fn session_id(&self) -> String

source

pub fn connected(&mut self, other: &mut InboundGroupSession) -> bool

Check if two InboundGroupSessions are the same.

An InboundGroupSession could be received multiple times with varying degrees of trust and first known message indices.

This method checks if the underlying ratchets of the two InboundGroupSessions are actually the same ratchet, potentially at a different ratcheting index. That is, if the sessions are connected, then ratcheting one of the ratchets to the index of the other should yield the same ratchet value, byte-for-byte. This will only be the case if the InboundGroupSessions were created from the same GroupSession.

If the sessions are connected, the session with the lower message index can safely replace the one with the higher message index.

source

pub fn compare(&mut self, other: &mut InboundGroupSession) -> SessionOrdering

Compare the InboundGroupSession with the given other InboundGroupSession.

Returns a SessionOrdering describing how the two sessions relate to each other.

source

pub fn merge( &mut self, other: &mut InboundGroupSession ) -> Option<InboundGroupSession>

Merge the session with the given other session, picking the best parts from each of them.

This method is useful when you receive multiple sessions with the same session ID but potentially different ratchet indices and authenticity properties.

For example, imagine you receive a SessionKey S1 with ratchet index A from a fully-trusted source and an ExportedSessionKey S2 with ratchet state B from a less trusted source. If A > B, then S1 is better because it’s fully trusted, but worse because it’s ratcheted further than S2.

This method allows you to merge S1 and S2 safely into a fully-trusted S3 with ratchet state B, provided S1 and S2 connect with each other (meaning they are the same session, just at different ratchet indices).

Returns Some(session) if the sessions could be merged, i.e. they are considered to be connected and None otherwise.

§Example

use vodozemac::megolm::{GroupSession, InboundGroupSession, SessionOrdering};

let session = GroupSession::new(Default::default());
let session_key = session.session_key();

let mut first_session = InboundGroupSession::new(&session_key, Default::default());
let mut second_session = InboundGroupSession::import(&first_session.export_at(10).unwrap(), Default::default());

assert_eq!(first_session.compare(&mut second_session), SessionOrdering::Better);

let mut merged = second_session.merge(&mut first_session).unwrap();

assert_eq!(merged.compare(&mut second_session), SessionOrdering::Better);
assert_eq!(merged.compare(&mut first_session), SessionOrdering::Equal);