Struct Envelope 

pub struct Envelope {
    pub ephemeral_key: Vec<u8>,
    pub encrypted_content: Vec<u8>,
    pub encrypted_headers: Vec<u8>,
}

An encrypted message envelope for transport.

Contains an ephemeral X25519 public key and XChaCha20-Poly1305 encrypted headers and content. Created by Message::enclose_for and opened by Envelope::open or Envelope::open_with_replay_guard.

Examples

use ma_core::{generate_identity_from_secret, Message, Envelope, EncryptionKey, SigningKey, Did};

let alice = generate_identity_from_secret([1u8; 32]).unwrap();
let bob = generate_identity_from_secret([2u8; 32]).unwrap();

let alice_sign_url = Did::new_url(&alice.subject_url.ipns, None::<String>).unwrap();
let alice_key = SigningKey::from_private_key_bytes(
    alice_sign_url,
    hex::decode(&alice.signing_private_key_hex).unwrap().try_into().unwrap(),
).unwrap();

let msg = Message::new(
    alice.document.id.clone(),
    bob.document.id.clone(),
    "text/plain",
    b"secret".to_vec(),
    &alice_key,
).unwrap();

// Encrypt for Bob
let envelope = msg.enclose_for(&bob.document).unwrap();

// Bob decrypts
let bob_enc_url = Did::new_url(&bob.subject_url.ipns, None::<String>).unwrap();
let bob_enc_key = EncryptionKey::from_private_key_bytes(
    bob_enc_url,
    hex::decode(&bob.encryption_private_key_hex).unwrap().try_into().unwrap(),
).unwrap();
let decrypted = envelope.open(&bob.document, &bob_enc_key, &alice.document).unwrap();
assert_eq!(decrypted.content, b"secret");

Fields

ephemeral_key: Vec<u8>

encrypted_content: Vec<u8>

encrypted_headers: Vec<u8>

Implementations

impl Envelope

pub fn verify(&self) -> Result<()>

pub fn encode(&self) -> Result<Vec<u8>>

pub fn decode(bytes: &[u8]) -> Result<Self>

pub fn open( &self, recipient_document: &Document, recipient_key: &EncryptionKey, sender_document: &Document, ) -> Result<Message>

pub fn open_with_replay_guard( &self, recipient_document: &Document, recipient_key: &EncryptionKey, sender_document: &Document, replay_guard: &mut ReplayGuard, ) -> Result<Message>

Trait Implementations

impl Clone for Envelope

fn clone(&self) -> Envelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Envelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Envelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Envelope

fn eq(&self, other: &Envelope) -> 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.

impl Serialize for Envelope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Envelope

impl StructuralPartialEq for Envelope