Enum KeyOperation 

#[non_exhaustive]
pub enum KeyOperation {
    Sign,
    Verify,
    Encrypt,
    Decrypt,
    WrapKey,
    UnwrapKey,
    DeriveKey,
    DeriveBits,
    Unknown(String),
}

Key operation (RFC 7517 Section 4.3).

Per RFC 7517, unknown key operation values should be accepted to support collision-resistant names and future extensions.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Sign

Compute digital signature or MAC.

Verify

Verify digital signature or MAC.

Encrypt

Encrypt content.

Decrypt

Decrypt content.

WrapKey

Encrypt key.

UnwrapKey

Decrypt key.

DeriveKey

Derive key.

DeriveBits

Derive bits not to be used as a key.

Unknown(String)

Unknown or private-use key operation.

Per RFC 7517, key operation values should either be registered in IANA or be a collision-resistant name. Unknown values are preserved.

Implementations

impl KeyOperation

pub fn as_str(&self) -> &str

Returns the key operation as a string.

pub fn is_unknown(&self) -> bool

Returns true if this is an unknown/unrecognized key operation.

Trait Implementations

impl Clone for KeyOperation

fn clone(&self) -> KeyOperation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyOperation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyOperation

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KeyOperation

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

Formats the value using the given formatter.

impl From<&str> for KeyOperation

fn from(s: &str) -> Self

Parses a key operation string.

Per RFC 7517, unknown key operation values are accepted and stored as Unknown.

impl FromStr for KeyOperation

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for KeyOperation

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 PartialEq for KeyOperation

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for KeyOperation

impl StructuralPartialEq for KeyOperation