Struct SignatureConfig 

pub struct SignatureConfig {
    pub typ: SignatureType,
    pub pub_alg: PublicKeyAlgorithm,
    pub hash_alg: HashAlgorithm,
    pub unhashed_subpackets: Vec<Subpacket>,
    pub hashed_subpackets: Vec<Subpacket>,
    pub version_specific: SignatureVersionSpecific,
}

The metadata of an OpenPGP Signature packet.

An OpenPGP Signature packet is split into a SignatureConfig (this struct), a two byte excerpt of the signed hash value, and the cryptographic signature as such.

A SignatureConfig specifies the “type” of a signature and the cryptographic algorithms that the signature uses.

In addition, it contains two lists of Subpackets:

• hashed_subpackets and
• unhashed_subpackets.

The subpackets in the list of hashed_subpackets are protected by the signature, they represent a part of the “semantics” of that signature.

The authenticity of hashed_subpackets is guaranteed if signature verification succeeds.

A Signature will usually include a subpacket with the SubpacketData::SignatureCreationTime in their hashed area, and usually other subpackets.

The unhashed_subpackets, by contracts, are not covered by the cryptographic signature. The contents of this area are thus not protected against tampering.

Potential uses of the unhashed_area:

• subpackets that can be independently verified by a recipient (e.g. SubpacketData::IssuerKeyId,
• annotations made on a signature by a third party, such as a key server (note that a third party can’t add data to the hashed area without breaking the cryptographic signature), or
• information that the sender wants to be able to plausibly deny

Fields

typ: SignatureType

pub_alg: PublicKeyAlgorithm

hash_alg: HashAlgorithm

unhashed_subpackets: Vec<Subpacket>

hashed_subpackets: Vec<Subpacket>

version_specific: SignatureVersionSpecific

Implementations

impl SignatureConfig

pub fn from_key<R: CryptoRng + Rng, S: SigningKey>( rng: R, key: &S, typ: SignatureType, ) -> Result<Self>

pub fn v2( typ: SignatureType, pub_alg: PublicKeyAlgorithm, hash_alg: HashAlgorithm, created: Timestamp, issuer_key_id: KeyId, ) -> Self

Constructor for a v2 SignatureConfig (which represents the data of a v2 OpenPGP signature packet)

OpenPGP v2 Signatures are historical and not used anymore.

pub fn v3( typ: SignatureType, pub_alg: PublicKeyAlgorithm, hash_alg: HashAlgorithm, created: Timestamp, issuer_key_id: KeyId, ) -> Self

Constructor for a v3 SignatureConfig (which represents the data of a v3 OpenPGP signature packet)

OpenPGP v3 Signatures are historical and not used anymore.

pub fn v4( typ: SignatureType, pub_alg: PublicKeyAlgorithm, hash_alg: HashAlgorithm, ) -> Self

Constructor for a v4 SignatureConfig (which represents the data of a v4 OpenPGP signature packet)

OpenPGP v4 signatures were first specified in RFC 2440, and are commonly produced by OpenPGP v4 keys.

pub fn v6<R: CryptoRng + Rng>( rng: R, typ: SignatureType, pub_alg: PublicKeyAlgorithm, hash_alg: HashAlgorithm, ) -> Result<Self>

Constructor for a v6 SignatureConfig (which represents the data of a v6 OpenPGP signature packet). Generates a new salt via rng.

OpenPGP v6 signatures are specified in RFC 9580, they are produced by OpenPGP v6 keys.

pub fn v6_with_salt( typ: SignatureType, pub_alg: PublicKeyAlgorithm, hash_alg: HashAlgorithm, salt: Vec<u8>, ) -> Self

Constructor for a v6 SignatureConfig (which represents the data of a v6 OpenPGP signature packet).

OpenPGP v6 signatures are specified in RFC 9580, they are produced by OpenPGP v6 keys.

pub fn version(&self) -> SignatureVersion

pub fn sign<R>( self, key: &impl SigningKey, key_pw: &Password, data: R, ) -> Result<Signature>

where R: Read,

Sign the given data.

pub fn into_hasher(self) -> Result<SignatureHasher>

pub fn sign_certification<S, K>( self, key: &S, pub_key: &K, key_pw: &Password, tag: Tag, id: &impl Serialize, ) -> Result<Signature>

where S: SigningKey, K: KeyDetails + Serialize,

Create a certification self-signature.

pub fn sign_certification_third_party<K>( self, signer: &impl SigningKey, signer_pw: &Password, signee: &K, tag: Tag, id: &impl Serialize, ) -> Result<Signature>

where K: KeyDetails + Serialize,

Create a certification third-party signature.

pub fn sign_subkey_binding<S, K1, K2>( self, signer: &S, signer_pub: &K1, signer_pw: &Password, signee: &K2, ) -> Result<Signature>

where S: SigningKey, K1: KeyDetails + Serialize, K2: KeyDetails + Serialize,

Sign a subkey binding that associates a subkey with a primary key.

The primary key is expected as signer, the subkey as signee.

Produces a “Subkey Binding Signature (type ID 0x18)”

pub fn sign_primary_key_binding<S, K1, K2>( self, signer: &S, signer_pub: &K1, signer_pw: &Password, signee: &K2, ) -> Result<Signature>

where S: SigningKey, K1: KeyDetails + Serialize, K2: KeyDetails + Serialize,

Sign a primary key binding, or “back signature” (with this signature, the subkey signals that it wants to be associated with the primary).

The subkey is expected as signer, the primary key as signee.

Produces a “Primary Key Binding Signature (type ID 0x19)”

pub fn sign_key<S, K>( self, signing_key: &S, key_pw: &Password, key: &K, ) -> Result<Signature>

where S: SigningKey, K: KeyDetails + Serialize,

Signs a direct key signature or a revocation.

pub fn typ(&self) -> SignatureType

Returns what kind of signature this is.

pub fn hash_signature_data( &self, hasher: &mut Box<dyn DynDigest + Send>, ) -> Result<usize>

Calculate the serialized version of this packet, but only the part relevant for hashing.

pub fn hash_data_to_sign<R>( &self, hasher: &mut Box<dyn DynDigest + Send>, data: R, ) -> Result<usize>

where R: Read,

pub fn trailer(&self, len: usize) -> Result<Vec<u8>>

pub fn subpackets(&self) -> impl Iterator<Item = &Subpacket>

👎Deprecated:

Usually only hashed_subpackets should be used. unhashed_subpackets are only safe and useful to access in rare circumstances. When they are needed, unhashed_subpackets should be explicitly called.

Returns an iterator of all subpackets in the signature: all subpackets in the hashed area followed by all subpackets in the unhashed area.

pub fn hashed_subpackets(&self) -> impl Iterator<Item = &Subpacket>

Returns an iterator over the hashed subpackets of this signature.

pub fn unhashed_subpackets(&self) -> impl Iterator<Item = &Subpacket>

Returns an iterator over the unhashed subpackets of this signature.

pub fn is_certification(&self) -> bool

Returns if the signature is a certification or not.

pub fn created(&self) -> Option<Timestamp>

Signature Creation Time.

The time the signature was made. MUST be present in the hashed area.

https://www.rfc-editor.org/rfc/rfc9580.html#name-signature-creation-time

Returns the first Signature Creation Time subpacket, only from the hashed area.

pub fn issuer_key_id(&self) -> Vec<&KeyId>

Issuer Key ID.

The OpenPGP Key ID of the key issuing the signature.

https://www.rfc-editor.org/rfc/rfc9580.html#name-issuer-key-id

Returns Issuer subpacket data from both the hashed and unhashed area.

pub fn issuer_fingerprint(&self) -> Vec<&Fingerprint>

Issuer Fingerprint.

The OpenPGP Key fingerprint of the key issuing the signature.

https://www.rfc-editor.org/rfc/rfc9580.html#name-issuer-fingerprint

Returns Issuer Fingerprint subpacket data from both the hashed and unhashed area.

Trait Implementations

impl Clone for SignatureConfig

fn clone(&self) -> SignatureConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignatureConfig

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

Formats the value using the given formatter.

impl Eq for SignatureConfig

impl PartialEq for SignatureConfig

fn eq(&self, other: &SignatureConfig) -> 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 StructuralPartialEq for SignatureConfig