Enum Message 

pub enum Message<'a> {
    Literal {
        reader: LiteralDataReader<MessageReader<'a>>,
        is_nested: bool,
    },
    Compressed {
        reader: CompressedDataReader<MessageReader<'a>>,
        is_nested: bool,
    },
    Signed {
        reader: SignatureManyReader<'a>,
        is_nested: bool,
    },
    Encrypted {
        esk: Vec<Esk>,
        edata: Edata<'a>,
        is_nested: bool,
    },
}

An OpenPGP message

Represents one of:

• Encrypted Message,
• Signed Message (either one-pass signed or prefixed-signed),
• Compressed Message,
• Literal Message.

OpenPGP message may consist of multiple layers wrapped around each other (such as for example: an encrypted message, containing a compressed message, containing a one-pass signed message, containing a literal message).

Variants

Literal

Literal Message: Literal Data Packet.

Fields

reader: LiteralDataReader<MessageReader<'a>>

is_nested: bool

is this a nested message?

Compressed

Compressed Message: Compressed Data Packet.

Fields

reader: CompressedDataReader<MessageReader<'a>>

is_nested: bool

is this a nested message?

Signed

Signed message, either

• Signed: Signature Packet, OpenPGP Message, or
• One Pass Signed: One-Pass Signature Packet, OpenPGP Message, Corresponding Signature Packet.

Fields

reader: SignatureManyReader<'a>

is_nested: bool

is this a nested message?

Encrypted

Encrypted Message: Encrypted Data | ESK Sequence, Encrypted Data.

Fields

esk: Vec<Esk>

ESK Sequence: ESK | ESK Sequence, ESK.

edata: Edata<'a>

is_nested: bool

is this a nested message?

Implementations

impl<'a> Message<'a>

pub fn from_bytes<R: BufRead + Debug + 'a + Send>(source: R) -> Result<Self>

Parses a message from the given bytes.

pub fn from_armor_file<P: AsRef<Path>>(path: P) -> Result<(Self, Headers)>

From armored file

pub fn from_string(data: &'a str) -> Result<(Self, Headers)>

From armored string

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

From binary file

pub fn from_armor<R: BufRead + Debug + 'a + Send>( input: R, ) -> Result<(Self, Headers)>

Armored ascii data.

pub fn from_armor_with_options<R: BufRead + Debug + 'a + Send>( input: R, opt: DearmorOptions, ) -> Result<(Self, Headers)>

Armored ascii data, with explicit options for dearmoring.

pub fn from_reader<R: BufRead + Debug + 'a + Send>( source: R, ) -> Result<(Self, Option<Headers>)>

Parse from a reader which might contain ASCII armored data or binary data.

impl<'a> Message<'a>

pub fn decompress(self) -> Result<Self>

Decompresses the data if compressed.

pub fn verify_nested( &self, keys: &[&dyn VerifyingKey], ) -> Result<Vec<VerificationResult>>

Recursively find all signatures found in this message and attempt to verify them against the passed in keys.

Only signed and one pass signed messages can be verified. The message must have been read to the end before calling this.

The current recursion limit is 1024.

pub fn verify_read(&mut self, key: &dyn VerifyingKey) -> Result<&Signature>

Reads the contents and discards it, then verifies the message.

pub fn verify(&self, key: &dyn VerifyingKey) -> Result<&Signature>

Verify this message.

Only signed and one pass signed messages can be verified. The message must have been read to the end before calling this.

If the signature is valid, returns the matching signature.

pub fn verify_nested_explicit( &self, index: usize, key: &dyn VerifyingKey, ) -> Result<&Signature>

pub fn decrypt( self, key_pw: &Password, key: &SignedSecretKey, ) -> Result<Message<'a>>

Decrypt the message using the given key. Returns a message decryptor.

pub fn decrypt_with_keys( self, key_passwords: Vec<&Password>, secret_keys: Vec<&SignedSecretKey>, ) -> Result<Message<'a>>

Decrypt the message using the given keys. Returns a message decryptor.

pub fn decrypt_legacy( self, key_pw: &Password, key: &SignedSecretKey, ) -> Result<Message<'a>>

Decrypt the message using the given key. Returns a message decryptor.

HAZMAT: Decrypts (malleable) SED packets.

pub fn decrypt_with_password(self, msg_pw: &Password) -> Result<Message<'a>>

Decrypt the message using the given key. Returns a message decryptor.

pub fn decrypt_with_session_key( self, session_key: PlainSessionKey, ) -> Result<Message<'a>>

pub fn decrypt_the_ring( self, ring: TheRing<'_>, abort_early: bool, ) -> Result<(Message<'a>, RingResult)>

The most powerful and flexible way to decrypt. Give it all you know, and maybe something will come of it.

If abort_early is true, the first available session key will be used, even if it might be wrong, or mismatch with others. If it is set to false, all provided keys, and passwords will be checked and compared. In this case, if there are different session keys found, it will error out.

pub fn is_one_pass_signed(&self) -> bool

Check if this message is a signature, that was signed with a one pass signature.

pub fn is_encrypted(&self) -> bool

pub fn is_signed(&self) -> bool

pub fn is_compressed(&self) -> bool

Is this a compressed message?

pub fn is_literal(&self) -> bool

Is this a literal message?

pub fn literal_data_header(&self) -> Option<&LiteralDataHeader>

If this is a literal message, returns the literal data header

pub fn packet_header(&self) -> PacketHeader

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

Consumes the reader and reads into a vec.

pub fn as_data_string(&mut self) -> Result<String>

Consumes the reader and reads into a string.

pub fn into_inner(self) -> PacketBodyReader<MessageReader<'a>>

pub fn get_mut(&mut self) -> &mut PacketBodyReader<MessageReader<'a>>

Trait Implementations

impl BufRead for Message<'_>

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data, via Read methods, if empty.

fn consume(&mut self, amt: usize)

Marks the given amount of additional bytes from the internal buffer as having been read. Subsequent calls to read only return bytes that have not been marked as read.

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Checks if there is any data left to be read.

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes into buf until the delimiter byte or EOF is reached.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<'a> Debug for Message<'a>

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

Formats the value using the given formatter.

impl Read for Message<'_>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Reads all bytes until EOF in this source, placing them into buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in big-endian order.