Struct UnsealedToken 

pub struct UnsealedToken<V, P, M, F = ()> {
    pub claims: M,
    pub footer: F,
    /* private fields */
}

An unsealed token.

This represents a PASETO which has had signatures or encryption validated. Using one of the following aliases is suggested

• UnsignedToken - A public PASETO which has had signature validated.
• UnencryptedToken - A local PASETO which has successfully been decrypted.

This type is un-serializable as it isn’t sealed. For that you will want SealedToken.

Fields

claims: M

The message that was contained in the token

footer: F

The footer that was sent with the token

Implementations

impl<V: Version, T: Purpose, M> UnsealedToken<V, T, M>

pub fn new(claims: M) -> Self

Create a new UnsealedToken builder with the given message payload

impl<V, T, M> UnsealedToken<V, T, M, ()>

pub fn with_footer<F>(self, footer: F) -> UnsealedToken<V, T, M, F>

Set the footer for this token.

Footers are embedded into the token as base64 only. They are authenticated but not encrypted.

impl<V, P, M, F> UnsealedToken<V, P, M, F>

where V: SealingVersion<P>, P: Purpose, M: Payload, F: Footer,

pub fn seal( self, key: &Key<V, P::SealingKey>, aad: &[u8], ) -> Result<SealedToken<V, P, M, F>, PasetoError>

Seal a token and authenticate the claims

pub fn dangerous_seal_with_nonce( self, key: &Key<V, P::SealingKey>, aad: &[u8], nonce: Vec<u8>, ) -> Result<SealedToken<V, P, M, F>, PasetoError>

Use UnsealedToken::seal instead.

This is provided for testing purposes only. Do not use this method directly.

impl<V, M, F> UnsealedToken<V, Local, M, F>

where V: SealingVersion<Local>, M: Payload, F: Footer,

pub fn encrypt( self, key: &LocalKey<V>, ) -> Result<EncryptedToken<V, M, F>, PasetoError>

Encrypt the token

pub fn encrypt_with_aad( self, key: &LocalKey<V>, aad: &[u8], ) -> Result<EncryptedToken<V, M, F>, PasetoError>

Encrypt the token, additionally authenticating the implicit assertions.

impl<V, M, F> UnsealedToken<V, Public, M, F>

where V: SealingVersion<Public>, M: Payload, F: Footer,

pub fn sign( self, key: &SecretKey<V>, ) -> Result<SignedToken<V, M, F>, PasetoError>

Sign the token

pub fn sign_with_aad( self, key: &SecretKey<V>, aad: &[u8], ) -> Result<SignedToken<V, M, F>, PasetoError>

Sign the token, additionally authenticating the implicit assertions.