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 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 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 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 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 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 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 should not be 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

pub fn as_ref(&self) -> &KeyFlags

Performs the conversion.

impl<'_> BitAnd<&'_ KeyFlags> for &'_ KeyFlags

type Output = KeyFlags

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'_> BitOr<&'_ KeyFlags> for &'_ KeyFlags

type Output = KeyFlags

The resulting type after applying the | operator.

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

Performs the | operation.

impl Clone for KeyFlags

pub fn clone(&self) -> KeyFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyFlags

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

Formats the value using the given formatter.

impl Eq for KeyFlags

impl Hash for KeyFlags

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

Feeds this value into the given Hasher.

pub 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

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<KeyFlags> for KeyFlags

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

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

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

This method tests for !=.

impl PartialOrd<KeyFlags> for KeyFlags

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

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

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

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

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

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

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

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

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

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

impl StructuralEq for KeyFlags

impl StructuralPartialEq for KeyFlags