Struct Rwt

pub struct Rwt<T> {
    pub payload: T,
    /* private fields */
}

Represents a web token.

For optimal usage, your payload should be any struct implementing Serialize, Deserialize, and FromStr, but none of these are technically required.

Fields

payload: T

Implementations

impl<T: Serialize> Rwt<T>

pub fn with_payload<S: AsRef<[u8]>>(payload: T, secret: S) -> Result<Rwt<T>>

Create a web token with the provided payload.

This function requires that the payload be Serialize.

pub fn encode(&self) -> Result<String>

Encode the token as base64 in the usual format.

In this case, “the usual format” means xxx.xxx where the left hand side is the token itself and the right hand side is the signature. The base64 implementation used currently introduces padding into the equation.

pub fn is_valid<S: AsRef<[u8]>>(&self, secret: S) -> bool

Validate the token.

This function compares the token as serialized against a freshly-derived signature to ensure that it is original and un-tampered-with. This version uses rust-crypto to compare the two results in order to protect against timing attacks.

Trait Implementations

impl<T: Debug> Debug for Rwt<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Rwt<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E> FromStr for Rwt<T>

where E: Display, T: FromStr<Err = E>,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl<T: PartialEq> PartialEq for Rwt<T>

fn eq(&self, other: &Rwt<T>) -> 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> Serialize for Rwt<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Rwt<T>

impl<T> StructuralPartialEq for Rwt<T>