Struct sequoia_openpgp::types::KeyFlags

pub struct KeyFlags(_);

Describes how a key may be used, and stores additional information.

Key flags are described in Section 5.2.3.21 of RFC 4880 and Section 5.2.3.22 of RFC 4880bis.

A note on equality

PartialEq compares the serialized form of the key flag sets. If you prefer to compare two key flag sets for semantic equality, you should use KeyFlags::normalized_eq. The difference between semantic equality and serialized equality is that semantic equality ignores differences in the amount of padding.

Examples

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

let p = &StandardPolicy::new();

let (cert, _) =
    CertBuilder::new()
        .add_userid("Alice <alice@example.com>")
        .add_transport_encryption_subkey()
        .generate()?;

for subkey in cert.with_policy(p, None)?.keys().subkeys() {
    // Key contains one Encryption subkey:
    assert!(subkey.key_flags().unwrap().for_transport_encryption());
}

Implementations

impl KeyFlags

pub fn new<B: AsRef<[u8]>>(bits: B) -> Self

Creates a new instance from bits.

pub fn empty() -> Self

Returns a new KeyFlags with all capabilities disabled.

pub fn normalized_eq(&self, other: &Self) -> bool

Compares two key flag sets for semantic equality.

KeyFlags’ implementation of PartialEq compares two key flag sets for serialized equality. That is, the PartialEq implementation considers two key flag sets to not be equal if they have different amounts of padding. This comparison function ignores padding.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::KeyFlags;

let a = KeyFlags::new(&[0x1]);
let b = KeyFlags::new(&[0x1, 0x0]);

assert!(a != b);
assert!(a.normalized_eq(&b));

pub fn get(&self, bit: usize) -> bool

Returns whether the specified key flag is set.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::KeyFlags;

// Key flags 0 and 2.
let kf = KeyFlags::new(&[0x5]);

assert!(kf.get(0));
assert!(! kf.get(1));
assert!(kf.get(2));
assert!(! kf.get(3));
assert!(! kf.get(8));
assert!(! kf.get(80));

pub fn set(self, bit: usize) -> Self

Sets the specified key flag.

This also clears any padding (trailing NUL bytes).

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::KeyFlags;

let kf = KeyFlags::empty().set(0).set(2);

assert!(kf.get(0));
assert!(! kf.get(1));
assert!(kf.get(2));
assert!(! kf.get(3));

pub fn clear(self, bit: usize) -> Self

Clears the specified key flag.

This also clears any padding (trailing NUL bytes).

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::KeyFlags;

let kf = KeyFlags::empty().set(0).set(2).clear(2);

assert!(kf.get(0));
assert!(! kf.get(1));
assert!(! kf.get(2));
assert!(! kf.get(3));

pub fn for_certification(&self) -> bool

This key may be used to certify other keys.

pub fn set_certification(self) -> Self

Declares that this key may be used to certify other keys.

pub fn clear_certification(self) -> Self

Declares that this key may not be used to certify other keys.

pub fn set_certification_to(self, value: bool) -> Self

Declares whether this key may be used to certify other keys.

pub fn for_signing(&self) -> bool

This key may be used to sign data.

pub fn set_signing(self) -> Self

Declares that this key may be used to sign data.

pub fn clear_signing(self) -> Self

Declares that this key may not be used to sign data.

pub fn set_signing_to(self, value: bool) -> Self

Declares whether this key may be used to sign data.

pub fn for_transport_encryption(&self) -> bool

This key may be used to encrypt communications.

pub fn set_transport_encryption(self) -> Self

Declares that this key may be used to encrypt communications.

pub fn clear_transport_encryption(self) -> Self

Declares that this key may not be used to encrypt communications.

pub fn set_transport_encryption_to(self, value: bool) -> Self

Declares whether this key may be used to encrypt communications.

pub fn for_storage_encryption(&self) -> bool

This key may be used to encrypt storage.

pub fn set_storage_encryption(self) -> Self

Declares that this key may be used to encrypt storage.

pub fn clear_storage_encryption(self) -> Self

Declares that this key may not be used to encrypt storage.

pub fn set_storage_encryption_to(self, value: bool) -> Self

Declares whether this key may be used to encrypt storage.

pub fn for_authentication(&self) -> bool

This key may be used for authentication.

pub fn set_authentication(self) -> Self

Declares that this key may be used for authentication.

pub fn clear_authentication(self) -> Self

Declares that this key may not be used for authentication.

pub fn set_authentication_to(self, value: bool) -> Self

Declares whether this key may be used for authentication.

pub fn is_split_key(&self) -> bool

The private component of this key may have been split using a secret-sharing mechanism.

pub fn set_split_key(self) -> Self

Declares that the private component of this key may have been split using a secret-sharing mechanism.

pub fn clear_split_key(self) -> Self

Declares that the private component of this key has not been split using a secret-sharing mechanism.

pub fn set_split_key_to(self, value: bool) -> Self

Declares whether the private component of this key may have been split using a secret-sharing mechanism.

pub fn is_group_key(&self) -> bool

The private component of this key may be in possession of more than one person.

pub fn set_group_key(self) -> Self

Declares that the private component of this key is in possession of more than one person.

pub fn clear_group_key(self) -> Self

Declares that the private component of this key should not be in possession of more than one person.

pub fn set_group_key_to(self, value: bool) -> Self

Declares whether the private component of this key is in possession of more than one person.

pub fn is_empty(&self) -> bool

Returns whether no flags are set.

Trait Implementations

impl AsRef<KeyFlags> for KeyFlags

fn as_ref(&self) -> &KeyFlags

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd<&KeyFlags> for &KeyFlags

type Output = KeyFlags

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> KeyFlags

Performs the & operation.

impl BitOr<&KeyFlags> for &KeyFlags

type Output = KeyFlags

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> KeyFlags

Performs the | operation.

impl Clone for KeyFlags

fn clone(&self) -> KeyFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyFlags

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

Formats the value using the given formatter.

impl Hash for KeyFlags

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 Ord for KeyFlags

fn cmp(&self, other: &KeyFlags) -> 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<KeyFlags> for KeyFlags

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

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

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

This method tests for !=.

impl PartialOrd<KeyFlags> for KeyFlags

fn partial_cmp(&self, other: &KeyFlags) -> 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 KeyFlags

impl StructuralEq for KeyFlags

impl StructuralPartialEq for KeyFlags