Struct RevocationKey

pub struct RevocationKey { /* private fields */ }

Designates a key as a valid third-party revoker.

This is described in Section 5.2.3.23 of RFC 9580.

Revocation keys can be retrieved using ValidAmalgamation::revocation_keys and set using CertBuilder::set_revocation_keys.

Examples

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

let p = &StandardPolicy::new();

let (alice, _) =
    CertBuilder::general_purpose(Some("alice@example.org"))
    .generate()?;

// Make Alice a designated revoker for Bob.
let (bob, _) =
    CertBuilder::general_purpose(Some("bob@example.org"))
    .set_revocation_keys(vec![(&alice).into()])
    .generate()?;

// Make sure Alice is listed as a designated revoker for Bob.
assert_eq!(bob.with_policy(p, None)?.revocation_keys()
               .collect::<Vec<&RevocationKey>>(),
           vec![&(&alice).into()]);

Implementations

impl RevocationKey

pub fn new( pk_algo: PublicKeyAlgorithm, fp: Fingerprint, sensitive: bool, ) -> Self

Creates a new instance.

pub fn from_bits( pk_algo: PublicKeyAlgorithm, fp: Fingerprint, class: u8, ) -> Result<Self>

Creates a new instance from the raw class parameter.

pub fn class(&self) -> u8

Returns the class octet, the sum of all flags.

pub fn revoker(&self) -> (PublicKeyAlgorithm, &Fingerprint)

Returns the revoker’s identity.

pub fn set_revoker( &mut self, pk_algo: PublicKeyAlgorithm, fp: Fingerprint, ) -> (PublicKeyAlgorithm, Fingerprint)

Sets the revoker’s identity.

pub fn sensitive(&self) -> bool

Returns whether the relation between revoker and revokee is of a sensitive nature.

pub fn set_sensitive(self, v: bool) -> Self

Sets whether the relation between revoker and revokee is of a sensitive nature.

Trait Implementations

impl Clone for RevocationKey

fn clone(&self) -> RevocationKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RevocationKey

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

Formats the value using the given formatter.

impl From<&Cert> for RevocationKey

fn from(cert: &Cert) -> Self

Converts to this type from the input type.

impl Hash for RevocationKey

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Marshal for RevocationKey

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 RevocationKey

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 RevocationKey

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RevocationKey

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

Tests for self and other values to be equal, and is used by ==.

const 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 PartialOrd for RevocationKey

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for RevocationKey

impl StructuralPartialEq for RevocationKey