Enum Algorithm 

#[non_exhaustive]
pub enum Algorithm {
    Hs256,
    Hs384,
    Hs512,
    Rs256,
    Rs384,
    Rs512,
    Ps256,
    Ps384,
    Ps512,
    Es256,
    Es384,
    Es512,
    Es256k,
    EdDsa,
    Ed25519,
    Ed448,
    RsaOaep,
    RsaOaep256,
    RsaOaep384,
    RsaOaep512,
    Rsa1_5,
    A128kw,
    A192kw,
    A256kw,
    Dir,
    EcdhEs,
    EcdhEsA128kw,
    EcdhEsA192kw,
    EcdhEsA256kw,
    A128gcmkw,
    A192gcmkw,
    A256gcmkw,
    Pbes2Hs256A128kw,
    Pbes2Hs384A192kw,
    Pbes2Hs512A256kw,
    A128cbcHs256,
    A192cbcHs384,
    A256cbcHs512,
    A128gcm,
    A192gcm,
    A256gcm,
    Unknown(String),
}

JWK Algorithm (RFC 7518).

Per RFC 7517, unknown algorithm values should be accepted and preserved to allow for future extensions and private-use algorithms.

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.

Hs256

HMAC using SHA-256.

Hs384

HMAC using SHA-384.

Hs512

HMAC using SHA-512.

Rs256

RSASSA-PKCS1-v1_5 using SHA-256.

Rs384

RSASSA-PKCS1-v1_5 using SHA-384.

Rs512

RSASSA-PKCS1-v1_5 using SHA-512.

Ps256

RSASSA-PSS using SHA-256 and MGF1 with SHA-256.

Ps384

RSASSA-PSS using SHA-384 and MGF1 with SHA-384.

Ps512

RSASSA-PSS using SHA-512 and MGF1 with SHA-512.

Es256

ECDSA using P-256 and SHA-256.

Es384

ECDSA using P-384 and SHA-384.

Es512

ECDSA using P-521 and SHA-512.

Es256k

ECDSA using secp256k1 and SHA-256.

EdDsa

Edwards-curve Digital Signature Algorithm (legacy JOSE identifier).

RFC 9864 deprecates this generic identifier in favor of the fully specified Algorithm::Ed25519 and Algorithm::Ed448 values.

Ed25519

Ed25519 signature algorithm (RFC 9864 JOSE algorithm identifier).

Ed448

Ed448 signature algorithm (RFC 9864 JOSE algorithm identifier).

RsaOaep

RSAES-OAEP using default parameters.

RsaOaep256

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

RsaOaep384

RSAES-OAEP using SHA-384 and MGF1 with SHA-384.

RsaOaep512

RSAES-OAEP using SHA-512 and MGF1 with SHA-512.

Rsa1_5

RSAES-PKCS1-v1_5.

A128kw

AES Key Wrap with 128-bit key.

A192kw

AES Key Wrap with 192-bit key.

A256kw

AES Key Wrap with 256-bit key.

Dir

Direct use of a shared symmetric key.

EcdhEs

ECDH-ES using Concat KDF.

EcdhEsA128kw

ECDH-ES using Concat KDF and A128KW wrapping.

EcdhEsA192kw

ECDH-ES using Concat KDF and A192KW wrapping.

EcdhEsA256kw

ECDH-ES using Concat KDF and A256KW wrapping.

A128gcmkw

Key wrapping with AES-GCM using 128-bit key.

A192gcmkw

Key wrapping with AES-GCM using 192-bit key.

A256gcmkw

Key wrapping with AES-GCM using 256-bit key.

Pbes2Hs256A128kw

PBES2 with HMAC SHA-256 and A128KW wrapping.

Pbes2Hs384A192kw

PBES2 with HMAC SHA-384 and A192KW wrapping.

Pbes2Hs512A256kw

PBES2 with HMAC SHA-512 and A256KW wrapping.

A128cbcHs256

AES-CBC with HMAC SHA-256 using 128-bit keys.

A192cbcHs384

AES-CBC with HMAC SHA-384 using 192-bit keys.

A256cbcHs512

AES-CBC with HMAC SHA-512 using 256-bit keys.

A128gcm

AES-GCM using 128-bit key.

A192gcm

AES-GCM using 192-bit key.

A256gcm

AES-GCM using 256-bit key.

Unknown(String)

Unknown or private-use algorithm.

Per RFC 7517, implementations should accept unknown algorithm values to support future extensions and collision-resistant names.

Implementations

impl Algorithm

pub fn as_str(&self) -> &str

Returns the algorithm as a string.

For unknown algorithms, this returns the original algorithm name.

pub fn is_unknown(&self) -> bool

Returns true if this is an unknown/unrecognized algorithm.

pub fn is_deprecated(&self) -> bool

Returns true if this algorithm identifier is deprecated.

Per RFC 9864, EdDSA is deprecated in JOSE in favor of the fully specified Ed25519 and Ed448 identifiers.

Trait Implementations

impl Clone for Algorithm

fn clone(&self) -> Algorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Algorithm

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Algorithm

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Algorithm

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

Formats the value using the given formatter.

impl From<&str> for Algorithm

fn from(s: &str) -> Self

Parses an algorithm string.

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

impl FromStr for Algorithm

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 Algorithm

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 Algorithm

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

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 Algorithm

impl StructuralPartialEq for Algorithm