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>

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

Formats the value using the given formatter.

impl<'a> Deref for MessageStructure<'a>

type Target = [MessageLayer<'a>]

The resulting type after dereferencing.

pub fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> IntoIterator for MessageStructure<'a>

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?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.