Struct Jwk 

#[non_exhaustive]
pub struct Jwk {
    pub algorithm: Algorithm,
    pub operations: HashSet<KeyOperation>,
    pub material: KeyMaterial,
    pub kid: Option<KeyId>,
    pub scope: Option<Scope>,
}

JWK, almost to spec (https://datatracker.ietf.org/doc/html/rfc7517) but not quite the same because it’s annoying to implement.

This is the serialized form of a key, with plain fields you can build and edit. It is not usable on its own: call import to validate it and get a usable Key, and Key::export to go back the other way. What that key may do is whatever key_ops allows, so a verify-only JWK imports fine and simply cannot sign.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

algorithm: Algorithm

The algorithm used by the key.

operations: HashSet<KeyOperation>

The permitted operations, defaulting to sign and verify when key_ops is absent (optional per RFC 7517 section 4.3).

material: KeyMaterial

The key material. Defaults to KeyMaterial::OCT when kty is absent.

kid: Option<KeyId>

The key ID, useful for rotating keys.

scope: Option<Scope>

Optional authorization limits for tokens signed by this key.

Implementations

impl Jwk

pub fn serialize<__S>( __self: &Jwk, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl<'de> Jwk

pub fn deserialize<__D>(__deserializer: __D) -> Result<Jwk, __D::Error>

where __D: Deserializer<'de>,

impl Jwk

pub fn new(algorithm: Algorithm, material: KeyMaterial) -> Self

A key that can both sign and verify, with no key ID or scope.

Set the remaining fields on the returned value. The struct is #[non_exhaustive], so building it this way keeps working as JWK parameters are added.

pub fn import(self) -> Result<Key>

Validate the parameters and import this as a usable Key.

The inverse of Key::export. Named rather than only a TryFrom impl so the conversion is discoverable from here, and import/export rather than validate because the validate methods elsewhere in this crate check without converting.

Trait Implementations

impl Clone for Jwk

fn clone(&self) -> Jwk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Jwk

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Key> for Jwk

fn from(key: &Key) -> Self

Converts to this type from the input type.

impl Serialize for Jwk

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Jwk> for Key

type Error = Error

The type returned in the event of a conversion error.

fn try_from(jwk: Jwk) -> Result<Self>

Performs the conversion.