Struct sequoia_openpgp::cert::amalgamation::ComponentAmalgamation

source ·

pub struct ComponentAmalgamation<'a, C> { /* private fields */ }

Expand description

A certificate component, its associated data, and useful methods.

Cert::userids, ValidCert::primary_userid, Cert::user_attributes, and Cert::unknowns return ComponentAmalgamations.

ComponentAmalgamation implements ValidateAmalgamation, which allows you to turn a ComponentAmalgamation into a ValidComponentAmalgamation using ComponentAmalgamation::with_policy.

See the module’s documentation for more details.

§Examples

// Iterate over all User IDs.
for ua in cert.userids() {
    // ua is a `ComponentAmalgamation`, specifically, a `UserIDAmalgamation`.
}

Implementations§

source §

pub fn cert(&self) -> &'a Cert

Returns the component’s associated certificate.

for u in cert.userids() {
    // It's not only an identical `Cert`, it's the same one.
    assert!(std::ptr::eq(u.cert(), &cert));
}

source

pub fn bundle(&self) -> &'a ComponentBundle<C>

Returns this amalgamation’s bundle.

Note: although ComponentAmalgamation derefs to a &ComponentBundle, this method provides a more accurate lifetime, which is helpful when returning the reference from a function. See the module’s documentation for more details.

§Examples

use openpgp::cert::prelude::*;
use openpgp::packet::prelude::*;

cert.userids()
    .map(|ua| {
        // The following doesn't work:
        //
        //   let b: &ComponentBundle<_> = &ua; b
        //
        // Because ua's lifetime is this closure and autoderef
        // assigns `b` the same lifetime as `ua`.  `bundle()`,
        // however, returns a reference whose lifetime is that
        // of `cert`.
        ua.bundle()
    })
    .collect::<Vec<&ComponentBundle<_>>>();

source

pub fn component(&self) -> &'a C

Returns this amalgamation’s component.

Note: although ComponentAmalgamation derefs to a &Component (via &ComponentBundle), this method provides a more accurate lifetime, which is helpful when returning the reference from a function. See the module’s documentation for more details.

source

pub fn self_signatures( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

The component’s self-signatures.

source

pub fn certifications( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

The component’s third-party certifications.

source

pub fn certifications_by_key<'b>( &'b self, issuers: &'b [KeyHandle] ) -> impl Iterator<Item = &'a Signature> + Send + Sync + 'b

Returns third-party certifications that appear to issued by any of the specified keys.

A certification is returned if one of the provided key handles matches an Issuer subpacket or Issuer Fingerprint subpacket in the certification.

This function does not check that a certification is valid. It can’t. To check that a certification was actually issued by a specific key, we also need a policy and the public key, which we don’t have. To only get valid certifications, use UserIDAmalgamation::valid_certifications_by_key or UserIDAmalgamation::active_certifications_by_key instead of this function.

source

it is well formed,
it is live with respect to the reference time,
it conforms to the policy, and
the signature is cryptographically valid.

This method is implemented on a UserIDAmalgamation and not a ValidUserIDAmalgamation, because a third-party certification does not require the user ID to be self signed.

§Examples

Alice has certified that a certificate belongs to Bob on two occasions. Whereas UserIDAmalgamation::valid_certifications_by_key returns both certifications, UserIDAmalgamation::active_certifications_by_key only returns the most recent certification.

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;

const P: &StandardPolicy = &StandardPolicy::new();

let alice: Cert = // ...
let bob: Cert = // ...

let ua = bob.userids().next().expect("have user id");

let valid_certifications = ua.valid_certifications_by_key(
    P, None, alice.primary_key().key());
// Alice certified Bob's certificate twice.
assert_eq!(valid_certifications.count(), 2);

let active_certifications = ua.active_certifications_by_key(
    P, None, alice.primary_key().key());
// But only the most recent one is active.
assert_eq!(active_certifications.count(), 1);

source

pub fn active_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Sync
where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

Returns any active third-party certifications issued by the specified key.

This function is like UserIDAmalgamation::valid_certifications_by_key, but it only returns active certifications. Active certifications are the most recent valid certifications with respect to the reference time.

Although there is normally only a single active certification, there can be multiple certifications with the same timestamp. In this case, all of them are returned.

Unlike self-signatures, multiple third-party certifications issued by the same key at the same time can be sensible. For instance, Alice may fully trust a CA for user IDs in a particular domain, and partially trust it for everything else. This can only be expressed using multiple certifications.

This method is implemented on a UserIDAmalgamation and not a ValidUserIDAmalgamation, because a third-party certification does not require the user ID to be self signed.

§Examples

See the examples for UserIDAmalgamation::valid_certifications_by_key.

source

pub fn valid_third_party_revocations_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Sync
where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

Returns the third-party revocations issued by the specified key, and valid at the specified time.

This function returns the revocations issued by the specified key. Specifically, it returns a revocation if:

it is well formed,
it is live with respect to the reference time,
it conforms to the policy, and
the signature is cryptographically valid.

This method is implemented on a UserIDAmalgamation and not a ValidUserIDAmalgamation, because a third-party revocation does not require the user ID to be self signed.

§Examples

Alice revokes a user ID on Bob’s certificate.

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;

const P: &StandardPolicy = &StandardPolicy::new();

let alice: Cert = // ...
let bob: Cert = // ...

let ua = bob.userids().next().expect("have user id");

let revs = ua.valid_third_party_revocations_by_key(
    P, None, alice.primary_key().key());
// Alice revoked the User ID.
assert_eq!(revs.count(), 1);

source

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>
where C: IntoIterator<Item = S>, S: Borrow<Signature>,

Attests to third-party certifications.

This feature is experimental.

Allows the certificate owner to attest to third party certifications. See Section 5.2.3.30 of RFC 4880bis for details. This can be used to address certificate flooding concerns.

A policy is needed, because the expiration is updated by updating the current binding signatures.

§Examples

let (alice, _) = CertBuilder::new()
    .add_userid("alice@example.org")
    .generate()?;
let mut alice_signer =
    alice.primary_key().key().clone().parts_into_secret()?
    .into_keypair()?;

let (bob, _) = CertBuilder::new()
    .add_userid("bob@example.org")
    .generate()?;
let mut bob_signer =
    bob.primary_key().key().clone().parts_into_secret()?
    .into_keypair()?;
let bob_pristine = bob.clone();

// Have Alice certify the binding between "bob@example.org" and
// Bob's key.
let alice_certifies_bob
    = bob.userids().next().unwrap().userid().bind(
        &mut alice_signer, &bob,
        SignatureBuilder::new(SignatureType::GenericCertification))?;
let bob = bob.insert_packets(vec![alice_certifies_bob.clone()])?;

// Have Bob attest that certification.
let bobs_uid = bob.userids().next().unwrap();
let attestations =
    bobs_uid.attest_certifications(
        policy,
        &mut bob_signer,
        bobs_uid.certifications())?;
let bob = bob.insert_packets(attestations)?;

assert_eq!(bob.bad_signatures().count(), 0);
assert_eq!(bob.userids().next().unwrap().certifications().next(),
           Some(&alice_certifies_bob));

source §

impl<'a> ComponentAmalgamation<'a, UserAttribute>

source

pub fn user_attribute(&self) -> &'a UserAttribute

Returns a reference to the User Attribute.

Note: although ComponentAmalgamation<UserAttribute> derefs to a &UserAttribute (via &ComponentBundle), this method provides a more accurate lifetime, which is helpful when returning the reference from a function. See the module’s documentation for more details.

source

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>
where C: IntoIterator<Item = S>, S: Borrow<Signature>,

Attests to third-party certifications.

This feature is experimental.

Allows the certificate owner to attest to third party certifications. See Section 5.2.3.30 of RFC 4880bis for details. This can be used to address certificate flooding concerns.

A policy is needed, because the expiration is updated by updating the current binding signatures.

§Examples

See UserIDAmalgamation::attest_certifications#examples.

Changes the key’s role tag to UnspecifiedRole.

source

pub fn component(&self) -> &C

Returns a reference to the bundle’s component.

§Examples

// Display some information about any unknown components.
for u in cert.unknowns() {
    eprintln!(" - {:?}", u.component());
}

source

pub fn binding_signature<T>( &self, policy: &dyn Policy, t: T ) -> Result<&Signature>
where T: Into<Option<SystemTime>>,

Returns the active binding signature at time t.

The active binding signature is the most recent, non-revoked self-signature that is valid according to the policy and alive at time t (creation time <= t, t < expiry). If there are multiple such signatures then the signatures are ordered by their MPIs interpreted as byte strings.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display information about each User ID's current active
// binding signature (the `time` parameter is `None`), if any.
for ua in cert.userids() {
    eprintln!("{:?}", ua.binding_signature(p, None));
}

source

pub fn self_signatures(&self) -> &[Signature]

Returns the component’s self-signatures.

The signatures are validated, and they are sorted by their creation time, most recent first.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for (i, ka) in cert.keys().enumerate() {
    eprintln!("Key #{} ({}) has {:?} self signatures",
              i, ka.fingerprint(),
              ka.bundle().self_signatures().len());
}

source

pub fn certifications(&self) -> &[Signature]

Returns the component’s third-party certifications.

The signatures are not validated. They are sorted by their creation time, most recent first.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for ua in cert.userids() {
    eprintln!("User ID {} has {:?} unverified, third-party certifications",
              String::from_utf8_lossy(ua.userid().value()),
              ua.bundle().certifications().len());
}

source

pub fn self_revocations(&self) -> &[Signature]

Returns the component’s revocations that were issued by the certificate holder.

The revocations are validated, and they are sorted by their creation time, most recent first.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for u in cert.userids() {
    eprintln!("User ID {} has {:?} revocation certificates.",
              String::from_utf8_lossy(u.userid().value()),
              u.bundle().self_revocations().len());
}

source

pub fn other_revocations(&self) -> &[Signature]

Returns the component’s revocations that were issued by other certificates.

The revocations are not validated. They are sorted by their creation time, most recent first.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for u in cert.userids() {
    eprintln!("User ID {} has {:?} unverified, third-party revocation certificates.",
              String::from_utf8_lossy(u.userid().value()),
              u.bundle().other_revocations().len());
}

source

pub fn attestations(&self) -> impl Iterator<Item = &Signature> + Send + Sync

Returns all of the component’s Attestation Key Signatures.

This feature is experimental.

The signatures are validated, and they are sorted by their creation time, most recent first.

A certificate owner can use Attestation Key Signatures to attest to third party certifications. Currently, only userid and user attribute certifications can be attested. See Section 5.2.3.30 of RFC 4880bis for details.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for (i, uid) in cert.userids().enumerate() {
    eprintln!("UserID #{} ({:?}) has {:?} attestation key signatures",
              i, uid.email(),
              uid.attestations().count());
}

source

pub fn signatures(&self) -> impl Iterator<Item = &Signature> + Send + Sync

Returns all of the component’s signatures.

Only the self-signatures are validated. The signatures are sorted first by type, then by creation time. The self revocations come first, then the self signatures, then any key attestation signatures, certifications, and third-party revocations coming last. This function may return additional types of signatures that could be associated to this component.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for (i, ka) in cert.keys().enumerate() {
    eprintln!("Key #{} ({}) has {:?} signatures",
              i, ka.fingerprint(),
              ka.signatures().count());
}

source

pub fn key(&self) -> &Key<P, R>

Returns a reference to the key.

This is just a type-specific alias for ComponentBundle::component.

§Examples

// Display some information about the keys.
for ka in cert.keys() {
    eprintln!(" - {:?}", ka.key());
}

source

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

Returns the subkey’s revocation status at time t.

A subkey is revoked at time t if:

There is a live revocation at time t that is newer than all live self signatures at time t, or
There is a hard revocation (even if it is not live at time t, and even if there is a newer self-signature).

Note: Certs and subkeys have different criteria from User IDs and User Attributes.

Note: this only returns whether this subkey is revoked; it does not imply anything about the Cert or other components.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display the subkeys' revocation status.
for ka in cert.keys().subkeys() {
    eprintln!(" Revocation status of {}: {:?}",
              ka.fingerprint(), ka.revocation_status(p, None));
}

source

pub fn userid(&self) -> &UserID

Returns a reference to the User ID.

This is just a type-specific alias for ComponentBundle::component.

§Examples

// Display some information about the User IDs.
for ua in cert.userids() {
    eprintln!(" - {:?}", ua.userid());
}

source

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

Returns the User ID’s revocation status at time t.

A User ID is revoked at time t if:

There is a live revocation at time t that is newer than all live self signatures at time t.

Note: Certs and subkeys have different criteria from User IDs and User Attributes.

Note: this only returns whether this User ID is revoked; it does not imply anything about the Cert or other components.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display the User IDs' revocation status.
for ua in cert.userids() {
    eprintln!(" Revocation status of {}: {:?}",
              String::from_utf8_lossy(ua.userid().value()),
              ua.revocation_status(p, None));
}

source

pub fn user_attribute(&self) -> &UserAttribute

Returns a reference to the User Attribute.

This is just a type-specific alias for ComponentBundle::component.

§Examples

// Display some information about the User Attributes
for ua in cert.user_attributes() {
    eprintln!(" - {:?}", ua.user_attribute());
}

source

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

Returns the User Attribute’s revocation status at time t.

A User Attribute is revoked at time t if:

There is a live revocation at time t that is newer than all live self signatures at time t.

Note: Certs and subkeys have different criteria from User IDs and User Attributes.

Note: this only returns whether this User Attribute is revoked; it does not imply anything about the Cert or other components.

§Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display the User Attributes' revocation status.
for (i, ua) in cert.user_attributes().enumerate() {
    eprintln!(" Revocation status of User Attribute #{}: {:?}",
              i, ua.revocation_status(p, None));
}

source

pub fn unknown(&self) -> &Unknown

Returns a reference to the unknown component.

This is just a type-specific alias for ComponentBundle::component.

§Examples

// Display some information about the User Attributes
for u in cert.unknowns() {
    eprintln!(" - {:?}", u.unknown());
}

Trait Implementations§

source §

impl<'a, C> Clone for ComponentAmalgamation<'a, C>

source §

fn clone(&self) -> Self

Returns a copy of the value. Read more

The resulting type after dereferencing.

source §

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

Dereferences the value.

source §

impl<'a, C> StructuralPartialEq for ComponentAmalgamation<'a, C>

Auto Trait Implementations§

§

source §

impl<T> From<T> for T

source §

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.

Implementations§

impl<'a, P, R> ComponentAmalgamation<'a, Key<P, R>>where P: KeyParts, R: KeyRole,

pub fn parts_into_public(self) -> ComponentAmalgamation<'a, Key<PublicParts, R>>

pub fn parts_as_public( &'a self ) -> &'a ComponentAmalgamation<'a, Key<PublicParts, R>>

pub fn parts_as_public_mut( &'a mut self ) -> &'a mut ComponentAmalgamation<'a, Key<PublicParts, R>>

pub fn parts_into_secret( self ) -> Result<ComponentAmalgamation<'a, Key<SecretParts, R>>>

pub fn parts_as_secret( &'a self ) -> Result<&'a ComponentAmalgamation<'a, Key<SecretParts, R>>>

pub fn parts_as_secret_mut( &'a mut self ) -> Result<&'a mut ComponentAmalgamation<'a, Key<SecretParts, R>>>

pub fn parts_into_unspecified( self ) -> ComponentAmalgamation<'a, Key<UnspecifiedParts, R>>

pub fn parts_as_unspecified( &'a self ) -> &ComponentAmalgamation<'a, Key<UnspecifiedParts, R>>

pub fn parts_as_unspecified_mut( &'a mut self ) -> &mut ComponentAmalgamation<'a, Key<UnspecifiedParts, R>>

impl<'a, P, R> ComponentAmalgamation<'a, Key<P, R>>where P: KeyParts, R: KeyRole,

pub fn role_into_primary(self) -> ComponentAmalgamation<'a, Key<P, PrimaryRole>>

pub fn role_as_primary( &'a self ) -> &'a ComponentAmalgamation<'a, Key<P, PrimaryRole>>

pub fn role_as_primary_mut( &'a mut self ) -> &'a mut ComponentAmalgamation<'a, Key<P, PrimaryRole>>

pub fn role_into_subordinate( self ) -> ComponentAmalgamation<'a, Key<P, SubordinateRole>>

pub fn role_as_subordinate( &'a self ) -> &'a ComponentAmalgamation<'a, Key<P, SubordinateRole>>

pub fn role_as_subordinate_mut( &'a mut self ) -> &'a mut ComponentAmalgamation<'a, Key<P, SubordinateRole>>

pub fn role_into_unspecified( self ) -> ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>

pub fn role_as_unspecified( &'a self ) -> &'a ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>

pub fn role_as_unspecified_mut( &'a mut self ) -> &'a mut ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>

impl<'a, C> ComponentAmalgamation<'a, C>

pub fn cert(&self) -> &'a Cert

pub fn bundle(&self) -> &'a ComponentBundle<C>

§Examples

pub fn component(&self) -> &'a C

pub fn self_signatures( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

pub fn certifications( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

pub fn certifications_by_key<'b>( &'b self, issuers: &'b [KeyHandle] ) -> impl Iterator<Item = &'a Signature> + Send + Sync + 'b

pub fn self_revocations( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

pub fn other_revocations( &self ) -> impl Iterator<Item = &'a Signature> + Send + Sync

pub fn signatures(&self) -> impl Iterator<Item = &'a Signature> + Send + Sync

impl<'a> ComponentAmalgamation<'a, UserID>

pub fn userid(&self) -> &'a UserID

pub fn valid_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Syncwhere T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

§Examples

pub fn active_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Syncwhere T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

§Examples

pub fn valid_third_party_revocations_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Syncwhere T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

§Examples

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>where C: IntoIterator<Item = S>, S: Borrow<Signature>,

§Examples

impl<'a> ComponentAmalgamation<'a, UserAttribute>

pub fn user_attribute(&self) -> &'a UserAttribute

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>where C: IntoIterator<Item = S>, S: Borrow<Signature>,

§Examples

Methods from Deref<Target = ComponentBundle<C>>§

pub fn parts_as_public(&self) -> &KeyBundle<PublicParts, R>

pub fn parts_as_secret(&self) -> Result<&KeyBundle<SecretParts, R>>

pub fn parts_as_unspecified(&self) -> &KeyBundle<UnspecifiedParts, R>

pub fn role_as_primary(&self) -> &KeyBundle<P, PrimaryRole>

pub fn role_as_subordinate(&self) -> &KeyBundle<P, SubordinateRole>

pub fn role_as_unspecified(&self) -> &KeyBundle<P, UnspecifiedRole>

pub fn component(&self) -> &C

§Examples

pub fn binding_signature<T>( &self, policy: &dyn Policy, t: T ) -> Result<&Signature>where T: Into<Option<SystemTime>>,

§Examples

pub fn self_signatures(&self) -> &[Signature]

§Examples

pub fn certifications(&self) -> &[Signature]

§Examples

pub fn self_revocations(&self) -> &[Signature]

§Examples

pub fn other_revocations(&self) -> &[Signature]

§Examples

pub fn attestations(&self) -> impl Iterator<Item = &Signature> + Send + Sync

§Examples

pub fn signatures(&self) -> impl Iterator<Item = &Signature> + Send + Sync

§Examples

pub fn key(&self) -> &Key<P, R>

§Examples

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>where T: Into<Option<SystemTime>>,

§Examples

pub fn userid(&self) -> &UserID

§Examples

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>where T: Into<Option<SystemTime>>,

§Examples

pub fn user_attribute(&self) -> &UserAttribute

Struct sequoia_openpgp::cert::amalgamation::ComponentAmalgamation

impl<'a, P, R> ComponentAmalgamation<'a, Key<P, R>>
where P: KeyParts, R: KeyRole,

impl<'a, P, R> ComponentAmalgamation<'a, Key<P, R>>
where P: KeyParts, R: KeyRole,

pub fn valid_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Sync
where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

pub fn active_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Sync
where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

pub fn valid_third_party_revocations_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK ) -> impl Iterator<Item = &Signature> + Send + Sync
where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>
where C: IntoIterator<Item = S>, S: Borrow<Signature>,

pub fn attest_certifications<C, S>( &self, policy: &dyn Policy, primary_signer: &mut dyn Signer, certifications: C ) -> Result<Vec<Signature>>
where C: IntoIterator<Item = S>, S: Borrow<Signature>,

pub fn binding_signature<T>( &self, policy: &dyn Policy, t: T ) -> Result<&Signature>
where T: Into<Option<SystemTime>>,

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T ) -> RevocationStatus<'_>
where T: Into<Option<SystemTime>>,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, PrimaryRole>>> for &'a ComponentAmalgamation<'a, Key<P, SubordinateRole>>
where P: KeyParts,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, PrimaryRole>>> for &'a ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>
where P: KeyParts,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, SubordinateRole>>> for &'a ComponentAmalgamation<'a, Key<P, PrimaryRole>>
where P: KeyParts,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, SubordinateRole>>> for &'a ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>
where P: KeyParts,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>> for &'a ComponentAmalgamation<'a, Key<P, PrimaryRole>>
where P: KeyParts,

impl<'a, P> From<&'a ComponentAmalgamation<'a, Key<P, UnspecifiedRole>>> for &'a ComponentAmalgamation<'a, Key<P, SubordinateRole>>
where P: KeyParts,

impl<'a, R> From<&'a ComponentAmalgamation<'a, Key<PublicParts, R>>> for &'a ComponentAmalgamation<'a, Key<UnspecifiedParts, R>>
where R: KeyRole,

impl<'a, R> From<&'a ComponentAmalgamation<'a, Key<SecretParts, R>>> for &'a ComponentAmalgamation<'a, Key<PublicParts, R>>
where R: KeyRole,

impl<'a, R> From<&'a ComponentAmalgamation<'a, Key<SecretParts, R>>> for &'a ComponentAmalgamation<'a, Key<UnspecifiedParts, R>>
where R: KeyRole,