Enum KeyManagementAlgorithm

pub enum KeyManagementAlgorithm {
    RSA1_5,
    RSA_OAEP,
    RSA_OAEP_256,
    A128KW,
    A192KW,
    A256KW,
    DirectSymmetricKey,
    ECDH_ES,
    ECDH_ES_A128KW,
    ECDH_ES_A192KW,
    ECDH_ES_A256KW,
    A128GCMKW,
    A192GCMKW,
    A256GCMKW,
    PBES2_HS256_A128KW,
    PBES2_HS384_A192KW,
    PBES2_HS512_A256KW,
}

Algorithms for key management as defined in RFC7518#4

Variants

RSA1_5

RSAES-PKCS1-v1_5

RSA_OAEP

RSAES OAEP using default parameters

RSA_OAEP_256

RSAES OAEP using SHA-256 and MGF1 with SHA-256

A128KW

AES Key Wrap using 128-bit key. Unsupported

A192KW

AES Key Wrap using 192-bit key. Unsupported. This is not supported by ring.

A256KW

AES Key Wrap using 256-bit key. Unsupported

DirectSymmetricKey

Direct use of a shared symmetric key

ECDH_ES

ECDH-ES using Concat KDF

ECDH_ES_A128KW

ECDH-ES using Concat KDF and “A128KW” wrapping

ECDH_ES_A192KW

ECDH-ES using Concat KDF and “A192KW” wrapping

ECDH_ES_A256KW

ECDH-ES using Concat KDF and “A256KW” wrapping

A128GCMKW

Key wrapping with AES GCM using 128-bit key alg

A192GCMKW

Key wrapping with AES GCM using 192-bit key alg. This is not supported by ring.

A256GCMKW

Key wrapping with AES GCM using 256-bit key alg

PBES2_HS256_A128KW

PBES2 with HMAC SHA-256 and “A128KW” wrapping

PBES2_HS384_A192KW

PBES2 with HMAC SHA-384 and “A192KW” wrapping

PBES2_HS512_A256KW

PBES2 with HMAC SHA-512 and “A256KW” wrapping

Implementations

impl KeyManagementAlgorithm

pub fn algorithm_type(self) -> KeyManagementAlgorithmType

Returns the type of operations that the algorithm is intended to support

pub fn cek<T>( self, content_alg: ContentEncryptionAlgorithm, key: &JWK<T>, ) -> Result<JWK<Empty>, Error>

where T: Serialize + DeserializeOwned,

Return the Content Encryption Key (CEK) based on the key management algorithm

If the algorithm is dir or DirectSymmetricKey, the key provided is the CEK. Otherwise, the appropriate algorithm will be used to derive or generate the required CEK using the provided key.

pub fn wrap_key<T>( self, payload: &[u8], key: &JWK<T>, options: &EncryptionOptions, ) -> Result<EncryptionResult, Error>

where T: Serialize + DeserializeOwned,

Encrypt or wrap a Content Encryption Key with the provided algorithm

pub fn unwrap_key<T>( self, encrypted: &EncryptionResult, content_alg: ContentEncryptionAlgorithm, key: &JWK<T>, ) -> Result<JWK<Empty>, Error>

where T: Serialize + DeserializeOwned,

Decrypt or unwrap a CEK with the provided algorithm

Trait Implementations

impl Clone for KeyManagementAlgorithm

fn clone(&self) -> KeyManagementAlgorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyManagementAlgorithm

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

Formats the value using the given formatter.

impl Default for KeyManagementAlgorithm

fn default() -> KeyManagementAlgorithm

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KeyManagementAlgorithm

fn deserialize<__D>( __deserializer: __D, ) -> Result<KeyManagementAlgorithm, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for KeyManagementAlgorithm

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for KeyManagementAlgorithm

impl Eq for KeyManagementAlgorithm

impl StructuralPartialEq for KeyManagementAlgorithm