Struct Decrypted

pub struct Decrypted<T, H = ()> {
    pub header: H,
    pub payload: T,
}

Rust representation of a JWE

Fields

header: H

Embedded header

payload: T

Payload, usually a signed/unsigned JWT

Implementations

impl<T> Decrypted<T>

pub fn new(payload: T) -> Self

Create a new JWE

impl<T> Decrypted<Json<T>>

pub fn new_json(payload: T) -> Self

Create a new json JWE

impl<T, H> Decrypted<T, H>

pub fn new_with_header(payload: T, header: H) -> Self

Create a new JWE with a custom header field

impl<T, H> Decrypted<T, H>

where T: ToCompactPart, H: Serialize + DeserializeOwned,

pub fn encrypt<CEA, KMA>( self, key: &KMA::Key, key_settings: KMA::WrapSettings, ) -> Result<Encrypted<KMA, H>, Error>

where CEA: CEA, KMA: KMA,

Encrypt an Decrypted JWE.

You will need to provide a jwa::EncryptionOptions that will differ based on your chosen algorithms.

If your cek_algorithm is not dir or direct, the options provided will be used to encrypt your content encryption key.

If your cek_algorithm is dir or Direct, then the options will be used to encrypt your content directly.

impl<P, H> Decrypted<ClaimsSet<P>, H>

where ClaimsSet<P>: Serialize + DeserializeOwned, H: Serialize + DeserializeOwned + Clone,

Convenience implementation for a Compact that contains a ClaimsSet

pub fn validate(&self, options: ValidationOptions) -> Result<(), Error>

Validate the temporal claims in the decoded token

If None is provided for options, the defaults will apply.

By default, no temporal claims (namely iat, exp, nbf) are required, and they will pass validation if they are missing.

Trait Implementations

impl<T: Clone, H: Clone> Clone for Decrypted<T, H>

fn clone(&self) -> Decrypted<T, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, H: Debug> Debug for Decrypted<T, H>

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

Formats the value using the given formatter.

impl<T: PartialEq, H: PartialEq> PartialEq for Decrypted<T, H>

fn eq(&self, other: &Decrypted<T, H>) -> 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<T: Eq, H: Eq> Eq for Decrypted<T, H>

impl<T, H> StructuralPartialEq for Decrypted<T, H>