Struct E2e 

pub struct E2e {
    pub available: bool,
    pub keys: Vec<Key>,
    pub settings: Settings,
    /* private fields */
}

What this run knows of end-to-end encryption: whether the server has it, the account’s keys and settings, those unlocked here, and the public keys of others looked up so far.

Fields

available: bool

keys: Vec<Key>

settings: Settings

Implementations

impl E2e

pub fn vaults_allowed(&self) -> bool

Whether vaults can be made here: the server has them and the tenant does not forbid them.

pub async fn open_names( &mut self, client: &Client, account: &str, nodes: &mut [FileNode], )

Fills in the real names of nodes in vaults whose key is at hand; the others stay locked, named by their id.

pub async fn open_name( &mut self, client: &Client, account: &str, vault: &str, sealed: &str, ) -> Option<String>

The real name of a node in a vault (kernoid:encryptedName) – None while the vault’s key is not at hand.

pub async fn name_in( &mut self, client: &Client, account: &str, vault: &str, name: &str, ) -> Result<(String, String)>

A name for a node in a vault: the id it gets as name and the real name encrypted, for kernoid:encryptedName.

pub async fn seal_content( &mut self, client: &Client, account: &str, vault: &str, data: Vec<u8>, ) -> Result<Vec<u8>>

Content for a vault: encrypted to its key and signed with the account’s, as a file’s blob there is.

pub async fn open_content( &mut self, client: &Client, account: &str, vault: &str, sealed: Vec<u8>, ) -> Result<Vec<u8>>

The content of a file of a vault, decrypted.

pub async fn move_in( &mut self, client: &Client, account: &str, vault: &str, id: &str, parent: &str, name: &str, ) -> Result<()>

Moves or renames a node within its vault: a new id for its name, the real name encrypted anew.

pub async fn create_vault( &mut self, client: &Client, account: &str, parent: Option<&str>, name: &str, ) -> Result<String>

Makes a vault in parent (None: the top of the store): its key here, the secret wrapped for the account’s own key, the name encrypted. Returns its id.

pub async fn create_directory_in( &mut self, client: &Client, account: &str, vault: &str, parent: &str, name: &str, ) -> Result<()>

A directory inside a vault.

pub async fn make_directory_in( &mut self, client: &Client, account: &str, vault: &str, parent: &str, name: &str, ) -> Result<String>

A directory inside a vault; returns its id.

pub async fn rename_in( &mut self, client: &Client, account: &str, node: &FileNode, name: &str, ) -> Result<()>

Renames a node in a vault: a new id for a name, the real one encrypted anew.

pub async fn upload_into( &mut self, client: &Client, account: &str, vault: &str, parent: &str, path: &Path, existing: Option<&FileNode>, progress: impl FnMut(u64, u64) + Send + 'static, ) -> Result<()>

Uploads a file into a directory of a vault, encrypted here to the vault’s key and signed with the account’s; existing (a file of the same real name) gets the new content.

pub async fn download_from( &mut self, client: &Client, account: &str, node: &FileNode, ) -> Result<Vec<u8>>

Downloads a file of a vault and decrypts it here; returns its content.

pub async fn save_from( &mut self, client: &Client, account: &str, node: &FileNode, path: &Path, ) -> Result<()>

Downloads a file of a vault, decrypted, into path.

pub async fn give_vault_keys( &mut self, client: &Client, account: &str, vault: &str, people: &[Principal], ) -> Result<Vec<Principal>>

After sharing a vault: gives its key to every person shared with who has a key of their own and no copy yet. Groups and people without a key wait (OPEN: a group’s members, as in the web app). Returns those who wait.

impl E2e

pub async fn load(client: &Client) -> Result<E2e>

Reads the account’s keys and settings – nothing if the server has no end-to-end extension.

pub async fn refresh(&mut self, client: &Client) -> Result<()>

Reads keys and settings again, keeping what is unlocked.

pub async fn setup(&mut self, client: &Client, kind: Kind) -> Result<String>

Makes the account’s key here (RFC 0006, 4.2) for the addresses it sends from, stores it with a copy protected by a new recovery code – and the tenant’s copy when its policy recovers keys (8.2) – and keeps it unlocked. Returns the recovery code, to be shown once.

pub fn current_key(&self) -> Option<&Key>

The key in use (not retired).

pub fn has_key(&self) -> bool

pub fn is_unlocked(&self) -> bool

pub fn unlock(&mut self, code: &str) -> Result<()>

Unlocks the key in use with the recovery code (as typed: separators and case do not matter) – and retired keys whose copy the same code opens. They stay in this process’s memory only.

pub fn lock(&mut self)

Forgets the unlocked keys.

pub async fn lookup( &mut self, client: &Client, addresses: &[String], ) -> Result<BTreeMap<String, Vec<PublicKey>>>

The public keys of addresses (asked once per run).

pub fn open_summary(&self, email: &mut EmailSummary)

Fills in subject, preview and attachments of an encrypted email from its summary, once the key is unlocked.

pub async fn open( &mut self, client: &Client, account: &str, email: Email, ) -> Result<Email>

An email to read: an encrypted one downloaded, decrypted and read into its parts here, its signature checked against its sender’s keys – locked if the key is not unlocked or does not open it. Other emails as they are.

pub async fn plan( &mut self, client: &Client, account: &str, identity: &Identity, draft: &Draft, ) -> Plan

How a message goes out: end-to-end encrypted if the key is unlocked, it is sent from the user’s own account as an address of the key, and every recipient has a key (RFC 0006, 5.3) – else as before.

pub fn draft_plan( &self, client: &Client, account: &str, identity: &Identity, draft: &Draft, ) -> Plan

Whether a draft is kept encrypted to the user’s own key – or why not.

pub async fn send( &self, client: &Client, outgoing: Outgoing<'_>, recipients: &[PublicKey], ) -> Result<()>

Sends end-to-end encrypted to recipients (from plan): the message built, encrypted and signed here, uploaded as it is, imported into Drafts with its summary encrypted to the sender, submitted with an envelope (To and Cc), and moved to Sent once sent.

pub async fn keep( &self, client: &Client, outgoing: Outgoing<'_>, keys: &[PublicKey], ) -> Result<()>

Keeps a draft encrypted to keys (from draft_plan).

pub async fn send_with( &self, client: &Client, outgoing: Outgoing<'_>, inline: &[InlineFile], recipients: &[PublicKey], ) -> Result<()>

send, with files held in memory attached as well – the attachments of an encrypted message forwarded (Email::decrypted_attachments).

pub async fn keep_with( &self, client: &Client, outgoing: Outgoing<'_>, inline: &[InlineFile], keys: &[PublicKey], ) -> Result<()>

keep, with files held in memory attached as well.

Trait Implementations

impl Debug for E2e

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

Formats the value using the given formatter.

impl Default for E2e

fn default() -> Self

Returns the “default value” for a type.