Enum sequoia_openpgp::packet::signature::subpacket::SubpacketValue

#[non_exhaustive]
pub enum SubpacketValue {
    Unknown {
        tag: SubpacketTag,
        body: Vec<u8>,
    },
    SignatureCreationTime(Timestamp),
    SignatureExpirationTime(Duration),
    ExportableCertification(bool),
    TrustSignature {
        level: u8,
        trust: u8,
    },
    RegularExpression(Vec<u8>),
    Revocable(bool),
    KeyExpirationTime(Duration),
    PreferredSymmetricAlgorithms(Vec<SymmetricAlgorithm>),
    RevocationKey(RevocationKey),
    Issuer(KeyID),
    NotationData(NotationData),
    PreferredHashAlgorithms(Vec<HashAlgorithm>),
    PreferredCompressionAlgorithms(Vec<CompressionAlgorithm>),
    KeyServerPreferences(KeyServerPreferences),
    PreferredKeyServer(Vec<u8>),
    PrimaryUserID(bool),
    PolicyURI(Vec<u8>),
    KeyFlags(KeyFlags),
    SignersUserID(Vec<u8>),
    ReasonForRevocation {
        code: ReasonForRevocation,
        reason: Vec<u8>,
    },
    Features(Features),
    SignatureTarget {
        pk_algo: PublicKeyAlgorithm,
        hash_algo: HashAlgorithm,
        digest: Vec<u8>,
    },
    EmbeddedSignature(Signature),
    IssuerFingerprint(Fingerprint),
    PreferredAEADAlgorithms(Vec<AEADAlgorithm>),
    IntendedRecipient(Fingerprint),
    AttestedCertifications(Vec<Box<[u8]>>),
}

Holds an arbitrary, well-structured subpacket.

The SubpacketValue enum holds a Subpacket’s value. The values are well structured in the sense that they have been parsed into Sequoia’s native data types rather than just holding the raw byte vector. For instance, the Issuer variant holds a KeyID.

Note: This enum cannot be exhaustively matched to allow future extensions.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unknown

An unknown subpacket.

Fields of Unknown

tag: SubpacketTag

The unknown subpacket’s tag.

body: Vec<u8>

The unknown subpacket’s uninterpreted body.

SignatureCreationTime(Timestamp)

The time the signature was made.

See Section 5.2.3.4 of RFC 4880 for details.

Tuple Fields of SignatureCreationTime

0: Timestamp

SignatureExpirationTime(Duration)

The validity period of the signature.

The validity is relative to the time stored in the signature’s Signature Creation Time subpacket.

See Section 5.2.3.10 of RFC 4880 for details.

Tuple Fields of SignatureExpirationTime

0: Duration

ExportableCertification(bool)

Whether a signature should be published.

See Section 5.2.3.11 of RFC 4880 for details.

Tuple Fields of ExportableCertification

0: bool

TrustSignature

Signer asserts that the key is not only valid but also trustworthy at the specified level.

See Section 5.2.3.13 of RFC 4880 for details.

Fields of TrustSignature

level: u8

Trust level, or depth.

Level 0 has the same meaning as an ordinary validity signature. Level 1 means that the signed key is asserted to be a valid trusted introducer, with the 2nd octet of the body specifying the degree of trust. Level 2 means that the signed key is asserted to be trusted to issue level 1 trust signatures, i.e., that it is a “meta introducer”.

trust: u8

Trust amount.

This is interpreted such that values less than 120 indicate partial trust and values of 120 or greater indicate complete trust. Implementations SHOULD emit values of 60 for partial trust and 120 for complete trust.

RegularExpression(Vec<u8>)

Used in conjunction with Trust Signature packets (of level > 0) to limit the scope of trust that is extended.

See Section 5.2.3.14 of RFC 4880 for details.

Note: The RFC requires that the serialized form includes a trailing NUL byte. When Sequoia parses the regular expression subpacket, it strips the trailing NUL. (If it doesn’t include a NUL, then parsing fails.) Likewise, when it serializes a regular expression subpacket, it unconditionally adds a NUL.

Tuple Fields of RegularExpression

0: Vec<u8>

Revocable(bool)

Whether a signature can later be revoked.

See Section 5.2.3.12 of RFC 4880 for details.

Tuple Fields of Revocable

0: bool

KeyExpirationTime(Duration)

The validity period of the key.

The validity period is relative to the key’s (not the signature’s) creation time.

See Section 5.2.3.6 of RFC 4880 for details.

Tuple Fields of KeyExpirationTime

0: Duration

PreferredSymmetricAlgorithms(Vec<SymmetricAlgorithm>)

The Symmetric algorithms that the certificate holder prefers.

See Section 5.2.3.7 of RFC 4880 for details.

Tuple Fields of PreferredSymmetricAlgorithms

0: Vec<SymmetricAlgorithm>

RevocationKey(RevocationKey)

Authorizes the specified key to issue revocation signatures for this certificate.

See Section 5.2.3.15 of RFC 4880 for details.

Tuple Fields of RevocationKey

0: RevocationKey

Issuer(KeyID)

The OpenPGP Key ID of the key issuing the signature.

See Section 5.2.3.5 of RFC 4880 for details.

Tuple Fields of Issuer

0: KeyID

NotationData(NotationData)

A “notation” on the signature.

See Section 5.2.3.16 of RFC 4880 for details.

Tuple Fields of NotationData

0: NotationData

PreferredHashAlgorithms(Vec<HashAlgorithm>)

The Hash algorithms that the certificate holder prefers.

See Section 5.2.3.8 of RFC 4880 for details.

Tuple Fields of PreferredHashAlgorithms

0: Vec<HashAlgorithm>

PreferredCompressionAlgorithms(Vec<CompressionAlgorithm>)

The compression algorithms that the certificate holder prefers.

See Section 5.2.3.9 of RFC 4880 for details.

Tuple Fields of PreferredCompressionAlgorithms

0: Vec<CompressionAlgorithm>

KeyServerPreferences(KeyServerPreferences)

A list of flags that indicate preferences that the certificate holder has about how the key is handled by a key server.

See Section 5.2.3.17 of RFC 4880 for details.

Tuple Fields of KeyServerPreferences

0: KeyServerPreferences

PreferredKeyServer(Vec<u8>)

The URI of a key server where the certificate holder keeps their certificate up to date.

See Section 5.2.3.18 of RFC 4880 for details.

Tuple Fields of PreferredKeyServer

0: Vec<u8>

PrimaryUserID(bool)

A flag in a User ID’s self-signature that states whether this User ID is the primary User ID for this certificate.

See Section 5.2.3.19 of RFC 4880 for details.

Tuple Fields of PrimaryUserID

0: bool

PolicyURI(Vec<u8>)

The URI of a document that describes the policy under which the signature was issued.

See Section 5.2.3.20 of RFC 4880 for details.

Tuple Fields of PolicyURI

0: Vec<u8>

KeyFlags(KeyFlags)

A list of flags that hold information about a key.

See Section 5.2.3.21 of RFC 4880 for details.

Tuple Fields of KeyFlags

0: KeyFlags

SignersUserID(Vec<u8>)

The User ID that is responsible for the signature.

See Section 5.2.3.22 of RFC 4880 for details.

Tuple Fields of SignersUserID

0: Vec<u8>

ReasonForRevocation

The reason for a revocation, used in key revocations and certification revocation signatures.

See Section 5.2.3.23 of RFC 4880 for details.

Fields of ReasonForRevocation

code: ReasonForRevocation

Machine-readable reason for revocation.

reason: Vec<u8>

Human-readable reason for revocation.

Features(Features)

The OpenPGP features a user’s implementation supports.

See Section 5.2.3.24 of RFC 4880 for details.

Tuple Fields of Features

0: Features

SignatureTarget

A signature to which this signature refers.

See Section 5.2.3.25 of RFC 4880 for details.

Fields of SignatureTarget

pk_algo: PublicKeyAlgorithm

Public-key algorithm of the target signature.

hash_algo: HashAlgorithm

Hash algorithm of the target signature.

digest: Vec<u8>

Hash digest of the target signature.

EmbeddedSignature(Signature)

A complete Signature packet body.

This is used to store a backsig in a subkey binding signature.

See Section 5.2.3.26 of RFC 4880 for details.

Tuple Fields of EmbeddedSignature

0: Signature

IssuerFingerprint(Fingerprint)

The Fingerprint of the key that issued the signature (proposed).

See Section 5.2.3.28 of RFC 4880bis for details.

Tuple Fields of IssuerFingerprint

0: Fingerprint

PreferredAEADAlgorithms(Vec<AEADAlgorithm>)

The AEAD algorithms that the certificate holder prefers (proposed).

See Section 5.2.3.8 of RFC 4880bis for details.

Tuple Fields of PreferredAEADAlgorithms

0: Vec<AEADAlgorithm>

IntendedRecipient(Fingerprint)

Who the signed message was intended for (proposed).

See Section 5.2.3.29 of RFC 4880bis for details.

Tuple Fields of IntendedRecipient

0: Fingerprint

AttestedCertifications(Vec<Box<[u8]>>)

The Attested Certifications subpacket (proposed).

Allows the certificate holder to attest to third party certifications, allowing them to be distributed with the certificate. This can be used to address certificate flooding concerns.

See Section 5.2.3.30 of RFC 4880bis for details.

Tuple Fields of AttestedCertifications

0: Vec<Box<[u8]>>

Implementations

impl SubpacketValue

pub fn tag(&self) -> SubpacketTag

Returns the subpacket tag for this value.

Trait Implementations

impl Clone for SubpacketValue

fn clone(&self) -> SubpacketValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubpacketValue

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

Formats the value using the given formatter.

impl Hash for SubpacketValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Marshal for SubpacketValue

fn serialize(&self, o: &mut dyn Write) -> Result<()>

Writes a serialized version of the object to o.

fn export(&self, o: &mut dyn Write) -> Result<()>

Exports a serialized version of the object to o.

impl MarshalInto for SubpacketValue

fn serialized_len(&self) -> usize

Computes the maximal length of the serialized representation.

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

Serializes into the given buffer.

fn to_vec(&self) -> Result<Vec<u8>>

Serializes the packet to a vector.

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

Exports into the given buffer.

fn export_to_vec(&self) -> Result<Vec<u8>>

Exports to a vector.

impl Ord for SubpacketValue

fn cmp(&self, other: &SubpacketValue) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<SubpacketValue> for SubpacketValue

fn eq(&self, other: &SubpacketValue) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SubpacketValue) -> bool

This method tests for !=.

impl PartialOrd<SubpacketValue> for SubpacketValue

fn partial_cmp(&self, other: &SubpacketValue) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for SubpacketValue

impl StructuralEq for SubpacketValue

impl StructuralPartialEq for SubpacketValue