Struct Session

pub struct Session {
    pub inner: Arc<Mutex<Session>>,
    pub session_id: Arc<str>,
    pub sender_key: Curve25519PublicKey,
    pub our_device_keys: DeviceKeys,
    pub created_using_fallback_key: bool,
    pub creation_time: SecondsSinceUnixEpoch,
    pub last_use_time: SecondsSinceUnixEpoch,
}

Cryptographic session that enables secure communication between two Accounts

Fields

inner: Arc<Mutex<Session>>

The OlmSession

session_id: Arc<str>

Our sessionId

sender_key: Curve25519PublicKey

The Key of the sender

our_device_keys: DeviceKeys

Our own signed device keys

created_using_fallback_key: bool

Has this been created using the fallback key

creation_time: SecondsSinceUnixEpoch

When the session was created

last_use_time: SecondsSinceUnixEpoch

When the session was last used

Implementations

impl Session

pub async fn decrypt( &mut self, message: &OlmMessage, ) -> Result<String, DecryptionError>

Decrypt the given Olm message.

Returns the decrypted plaintext or a DecryptionError if decryption failed.

Arguments

• message - The Olm message that should be decrypted.

pub fn sender_key(&self) -> Curve25519PublicKey

Get the sender key that was used to establish this Session.

pub async fn session_config(&self) -> SessionConfig

Get the SessionConfig that this session is using.

pub async fn algorithm(&self) -> EventEncryptionAlgorithm

Get the EventEncryptionAlgorithm of this Session.

pub async fn encrypt( &mut self, recipient_device: &DeviceData, event_type: &str, content: impl Serialize, message_id: Option<String>, ) -> Result<Raw<ToDeviceEncryptedEventContent>, OlmError>

Encrypt the given event content as an m.room.encrypted event content.

Arguments

• recipient_device - The device for which this message is going to be encrypted, this needs to be the device that was used to create this session with.

• event_type - The type of the event content.

• content - The content of the event.

pub fn session_id(&self) -> &str

Returns the unique identifier for this session.

pub async fn pickle(&self) -> PickledSession

Store the session as a base64 encoded string.

Arguments

• pickle_mode - The mode that was used to pickle the session, either an unencrypted mode or an encrypted using passphrase.

pub fn from_pickle( our_device_keys: DeviceKeys, pickle: PickledSession, ) -> Result<Self, SessionUnpickleError>

Restore a Session from a previously pickled string.

Returns the restored Olm Session or a SessionUnpicklingError if there was an error.

Arguments

• our_device_keys - Our own signed device keys.

• pickle - The pickled version of the Session.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Session

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Session

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.