[][src]Struct sequoia_openpgp::parse::stream::MessageStructure

pub struct MessageStructure<'a>(_);

Communicates the message structure to the VerificationHelper.

A valid OpenPGP message contains one literal data packet with optional encryption, signing, and compression layers freely combined on top. This structure is passed to VerificationHelper::check for verification.

The most common structure is an optionally encrypted, optionally compressed, and optionally signed message, i.e. if the message is encrypted, then the encryption is the outermost layer; if the message is signed, then the signature group is the innermost layer. This is a sketch of such a message:

[ encryption layer: [ compression layer: [ signature group: [ literal data ]]]]

However, OpenPGP allows encryption, signing, and compression operations to be freely combined (see Section 11.3 of RFC 4880). This is represented as a stack of MessageLayers, where signatures of the same level (i.e. those over the same data: either directly over the literal data, or over other signatures and the literal data) are grouped into one layer. See also Signature::level.

Consider the following structure. This is a set of notarizing signatures N over a set of signatures S over the literal data:

[ signature group: [ signature group: [ literal data ]]]

The notarizing signatures N are said to be of level 1, i.e. signatures over the signatures S and the literal data. The signatures S are level 0 signatures, i.e. signatures over the literal data.

OpenPGP's flexibility allows adaption to new use cases, but also presents a challenge to implementations and downstream users. The message structure must be both validated, and possibly communicated to the application's user. Note that if compatibility is a concern, generated messages must be restricted to a narrow subset of possible structures, see this test of unusual message structures.

Trait Implementations

impl<'a> Debug for MessageStructure<'a>[src]

impl<'a> Deref for MessageStructure<'a>[src]

type Target = [MessageLayer<'a>]

The resulting type after dereferencing.

impl<'a> IntoIterator for MessageStructure<'a>[src]

type Item = MessageLayer<'a>

The type of the elements being iterated over.

type IntoIter = IntoIter<MessageLayer<'a>>

Which kind of iterator are we turning this into?

Auto Trait Implementations

impl<'a> !RefUnwindSafe for MessageStructure<'a>

impl<'a> Send for MessageStructure<'a>

impl<'a> Sync for MessageStructure<'a>

impl<'a> Unpin for MessageStructure<'a>

impl<'a> !UnwindSafe for MessageStructure<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<I> IntoIterator for I where
    I: Iterator

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.