Struct jwt_compact::alg::StrongAlg

pub struct StrongAlg<T>(pub T);

Wrapper around a JWT algorithm signalling that it supports only StrongKeys.

The wrapper will implement Algorithm if the wrapped value is an Algorithm with both signing and verifying keys convertible to StrongKeys.

Examples

let weak_key = Hs256Key::new(b"too short!");
assert!(StrongKey::try_from(weak_key).is_err());
// There is no way to create a `StrongKey` from `weak_key`!

let strong_key: StrongKey<_> = Hs256Key::generate(&mut thread_rng());
let claims = // ...
let token = StrongAlg(Hs256)
    .token(Header::default(), &claims, &strong_key)?;

Tuple Fields

0: T

Trait Implementations

impl<T: Algorithm> Algorithm for StrongAlg<T>where StrongKey<T::SigningKey>: TryFrom<T::SigningKey>, StrongKey<T::VerifyingKey>: TryFrom<T::VerifyingKey>,

type SigningKey = StrongKey<<T as Algorithm>::SigningKey>

Key used when issuing new tokens.

type VerifyingKey = StrongKey<<T as Algorithm>::VerifyingKey>

Key used when verifying tokens. May coincide with Self::SigningKey for symmetric algorithms (e.g., HS*).

type Signature = <T as Algorithm>::Signature

Signature produced by the algorithm.

fn name(&self) -> Cow<'static, str>

Returns the name of this algorithm, as mentioned in the alg field of the JWT header.

fn sign( &self, signing_key: &Self::SigningKey, message: &[u8] ) -> Self::Signature

Signs a message with the signing_key.

fn verify_signature( &self, signature: &Self::Signature, verifying_key: &Self::VerifyingKey, message: &[u8] ) -> bool

Verifies the message against the signature and verifying_key.

impl<T: Clone> Clone for StrongAlg<T>

fn clone(&self) -> StrongAlg<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StrongAlg<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for StrongAlg<T>

fn default() -> StrongAlg<T>

Returns the “default value” for a type.

impl<T: Copy> Copy for StrongAlg<T>